package rconv

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"gameServer/encoding/json"
	"gameServer/utils/rreflect"
	"reflect"
	"regexp"
	"strconv"
	"strings"
	"time"
	"unicode/utf8"
	"unsafe"
)

/* String */

// String 将任意输入类型（基本类型、指针、时间、字节切片等）转换为字符串，
// 支持常见基础类型的精准转换，复杂类型（如自定义结构体）通过反射+JSON序列化兜底，
// 空输入（nil）返回空字符串，避免空指针异常。
// 参数：
//
//	any: 待转换的任意类型（如 int、*float64、time.Time、[]byte 等）
//
// 返回值：
//
//	string: 转换后的字符串，空输入或零值（如零时间）可能返回空字符串
func String(any interface{}) string {
	// 处理空输入：若输入为nil，直接返回空字符串
	if any == nil {
		return ""
	}

	// 类型断言分支：精准匹配常见基础类型，优先于反射处理（性能更优）
	switch v := any.(type) {
	// -------------------------- 整数类型转换 --------------------------
	// 处理 int 类型：通过 strconv.Itoa 转换（Itoa 专门用于 int 转字符串）
	case int:
		return strconv.Itoa(v)
	// 处理 *int 类型：先解引用获取int值，再调用 Itoa 转换
	case *int:
		return strconv.Itoa(*v)
	// 处理 int8 类型：先转为 int（Itoa 不支持 int8），再调用 Itoa
	case int8:
		return strconv.Itoa(int(v))
	// 处理 *int8 类型：解引用后转 int，再调用 Itoa
	case *int8:
		return strconv.Itoa(int(*v))
	// int16、*int16、int32、*int32 转换逻辑与 int8 一致：转 int 后用 Itoa
	case int16:
		return strconv.Itoa(int(v))
	case *int16:
		return strconv.Itoa(int(*v))
	case int32:
		return strconv.Itoa(int(v))
	case *int32:
		return strconv.Itoa(int(*v))
	// 处理 int64 类型：Itoa 仅支持 int（可能因平台不同为32/64位），用 FormatInt 确保兼容
	case int64:
		return strconv.FormatInt(v, 10) // 10 表示十进制
	case *int64:
		return strconv.FormatInt(*v, 10)

	// -------------------------- 无符号整数类型转换 --------------------------
	// 处理 uint 类型：转 int 后用 Itoa（注意：若 uint 超出 int 范围，可能丢失精度，适合小数值场景）
	case uint:
		return strconv.Itoa(int(v))
	case *uint:
		return strconv.Itoa(int(*v))
	// uint8、*uint8、uint16、*uint16、uint32、*uint32 逻辑与 uint 一致：转 int 后用 Itoa
	case uint8:
		return strconv.Itoa(int(v))
	case *uint8:
		return strconv.Itoa(int(*v))
	case uint16:
		return strconv.Itoa(int(v))
	case *uint16:
		return strconv.Itoa(int(*v))
	case uint32:
		return strconv.Itoa(int(v))
	case *uint32:
		return strconv.Itoa(int(*v))
	case uint64:
		return strconv.FormatUint(uint64(v), 10)
	case *uint64:
		return strconv.FormatUint(uint64(*v), 10)

	// -------------------------- 浮点数类型转换 --------------------------
	// 处理 float32 类型：用 FormatFloat 转换，参数含义：
	// - float64(v)：将 float32 转为 float64（FormatFloat 仅支持 float64）
	// - 'f'：固定小数格式（非科学计数法）
	// - -1：自动决定小数位数（移除末尾多余的0和小数点）
	// - 32：表示原始类型是 float32（用于精度控制）
	case float32:
		return strconv.FormatFloat(float64(v), 'f', -1, 32)
	case *float32:
		return strconv.FormatFloat(float64(*v), 'f', -1, 64) // 解引用后按 float64 处理
	// 处理 float64 类型：直接用 FormatFloat，原始类型为 64 位
	case float64:
		return strconv.FormatFloat(v, 'f', -1, 64)
	case *float64:
		return strconv.FormatFloat(*v, 'f', -1, 64)

	// -------------------------- 复数类型转换 --------------------------
	// 处理 complex64 类型：用 FormatComplex 转换，参数 'e' 表示科学计数法（适配复数的实部/虚部）
	case complex64:
		return strconv.FormatComplex(complex128(v), 'e', -1, 64) // 转 complex128 后处理
	case complex128:
		return strconv.FormatComplex(v, 'e', -1, 128)
	case *complex64:
		return strconv.FormatComplex(complex128(*v), 'e', -1, 64)
	case *complex128:
		return strconv.FormatComplex(*v, 'e', -1, 128)

	// -------------------------- 布尔类型转换 --------------------------
	// 处理 bool 类型：用 FormatBool 直接转换（返回 "true" 或 "false"）
	case bool:
		return strconv.FormatBool(v)
	case *bool:
		return strconv.FormatBool(*v)

	// -------------------------- 字符串类型转换 --------------------------
	// 处理 string 类型：直接返回（无需转换）
	case string:
		return v
	// 处理 *string 类型：解引用后返回
	case *string:
		return *v

	// -------------------------- 字节切片类型转换 --------------------------
	// 处理 []byte 类型：通过 unsafe.Pointer 直接转换底层数组，避免内存拷贝（性能优化）
	// 注意：转换后 string 与原 []byte 共享底层内存，修改原 []byte 会导致 string 内容变化（非线程安全）
	// 直接转指针不安全，用unsafe 从指针角度讲，转了以后能正常使用，说明string包含[]byte且正常对齐
	case []byte:
		return *(*string)(unsafe.Pointer(&v))
	// 处理 *[]byte 类型：先解引用获取 []byte，再通过 unsafe 转换
	case *[]byte:
		return *(*string)(unsafe.Pointer(v))

	// -------------------------- 时间类型转换 --------------------------
	// 处理 time.Time 类型：若为零时间（如 time.Time{}）返回空字符串，否则调用 Time.String()
	// 零时间判断：业务上通常无需显示 "0001-01-01 00:00:00 +0000 UTC"，故返回空
	case time.Time:
		if v.IsZero() {
			return ""
		}
		return v.String()
	case *time.Time:
		if v.IsZero() {
			return ""
		}
		return v.String()

	// -------------------------- 兜底处理（复杂类型） --------------------------
	// 若上述类型均不匹配（如自定义结构体、切片等），通过反射+JSON序列化处理
	default:
		var (
			rv = reflect.ValueOf(any) // 获取输入的反射值（包含类型和数据）
			// go的反射语法  获取一个reflect.Value结构体，里面存放目标的类型和值
			// 举例：
			/*
				输入是 &User{Name: "张三", Age: 20}（User 是结构体，有 Name 和 Age 两个可导出字段），reflect.ValueOf(any) 会返回一个 reflect.Value，里面记录：
				类型：*User（指针类型，指向 User 结构体）；
				数据：指针指向的 User 实例（Name="张三", Age=20）；
				可操作能力：可以解引用指针、获取结构体成员值等。
			*/

			kind = rv.Kind() // 获取反射类型的 Kind（如 Ptr、Struct、Slice 等）
			// 这些是go的大致类型
		)

		// 能出现在这里，就表明是一个多级指针或者是一个复合类型，切片，结构体等

		// 循环解引用指针：若输入是指针（或指向指针的指针），一直解引用到具体类型
		// 例：*(*int) → *int → int，确保后续能拿到实际数据
		for kind == reflect.Ptr {
			// 这一步是反复解引用得到那个类型，最后得到的不是大类Ptr就继续
			rv = rv.Elem()   // 解引用：获取指针指向的实际值
			kind = rv.Kind() // 更新 Kind 为解引用后的类型
		}

		// 根据解引用后的 Kind 分类处理，复用 String 函数逻辑（递归调用，避免重复代码）
		switch kind {
		case reflect.Invalid: // 无效类型（如 nil 已在开头处理，此处理论不触发）
			return ""
		case reflect.Bool: // 布尔类型：调用 String 转换
			return String(rv.Bool())
		case reflect.String: // 字符串类型：调用 String 转换
			return String(rv.String())
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: // 整数类型
			return String(rv.Int())
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: // 无符号整数
			return String(rv.Uint())
		case reflect.Float32, reflect.Float64: // 浮点数类型
			return String(rv.Float())
		case reflect.Complex64, reflect.Complex128: // 复数类型
			return String(rv.Complex())
		// 其他类型（如 Struct、Map 等）：用 JSON 序列化转为字符串，失败则用 fmt 兜底
		default:
			// 尝试 JSON 序列化（适合自定义结构体，需字段可导出）
			b, err := json.Marshal(v)
			if err != nil {
				// 序列化失败（如字段不可导出），用 fmt.Sprintf("%v", v) 兜底（输出类型的默认字符串表示）
				// 调用默认输出
				return fmt.Sprintf("%v", v)
			}
			// 将 JSON 字节切片转为字符串（复用 unsafe 转换优化性能）
			return *(*string)(unsafe.Pointer(&b))
		}
	}
}

// Strings 将任意切片/数组类型（含指针指向的切片）转换为 []string，
// 支持基础类型切片（如 []int、[]bool）、字符串切片、字节切片等，
// 复杂切片（如 []struct）通过反射处理，空输入（nil）返回空切片。
// 参数：
//
//	any: 待转换的切片/数组类型（如 []int、*[]float64、[][]byte 等）
//
// 返回值：
//
//	[]string: 转换后的字符串切片，空输入返回空切片
func Strings(any interface{}) (slice []string) {
	// 处理空输入：若输入为nil，直接返回空切片
	if any == nil {
		return
	}

	// 类型断言分支：精准匹配常见切片类型，优先于反射处理（性能更优）
	switch v := any.(type) {
	// -------------------------- 整数切片转换 --------------------------
	// 处理 []int 类型：创建同长度的 []string，循环调用 String 转换每个元素
	case []int:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	// 处理 *[]int 类型：先解引用获取切片，再按 []int 逻辑转换
	case *[]int:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}
	// []int8、*[]int8、[]int16、*[]int16、[]int32、*[]int32、[]int64、*[]int64 逻辑一致：
	// 解引用（若为指针）→ 创建同长度切片 → 循环调用 String 转换
	case []int8:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]int8:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}
	case []int16:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]int16:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}
	case []int32:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]int32:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}
	case []int64:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]int64:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}

	// -------------------------- 无符号整数切片转换 --------------------------
	// []uint、*[]uint 及其他无符号整数切片逻辑与整数切片一致：
	// 解引用 → 创建切片 → 循环调用 String 转换
	case []uint:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]uint:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}
	case []uint8:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]uint8:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}
	case []uint16:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]uint16:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}
	case []uint32:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]uint32:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}
	case []uint64:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]uint64:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}

	// -------------------------- 浮点数切片转换 --------------------------
	// []float32、*[]float32、[]float64、*[]float64 逻辑一致：
	// 解引用 → 创建切片 → 循环调用 String 转换
	case []float32:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]float32:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}
	case []float64:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]float64:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}

	// -------------------------- 复数切片转换 --------------------------
	// []complex64、*[]complex64、[]complex128、*[]complex128 逻辑一致：
	// 解引用 → 创建切片 → 循环调用 String 转换
	case []complex64:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]complex64:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}
	case []complex128:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]complex128:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}

	// -------------------------- 字符串切片转换 --------------------------
	// 处理 []string 类型：直接返回（无需转换）
	case []string:
		return v
	// 处理 *[]string 类型：解引用后返回
	case *[]string:
		return *v

	// -------------------------- 布尔切片转换 --------------------------
	// []bool、*[]bool 逻辑一致：解引用 → 创建切片 → 循环调用 String 转换
	case []bool:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]bool:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}

	// -------------------------- 空接口切片转换 --------------------------
	// 处理 []interface{} 类型：循环获取每个元素的实际值，调用 String 转换
	case []interface{}:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[]interface{}:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}

	// -------------------------- 二维字节切片转换 --------------------------
	// 处理 [][]byte 类型：循环将每个 []byte 转为 string（复用 String 函数的 unsafe 优化）
	case [][]byte:
		slice = make([]string, len(v))
		for i := range v {
			slice[i] = String(v[i])
		}
	case *[][]byte:
		slice = make([]string, len(*v))
		for i := range *v {
			slice[i] = String((*v)[i])
		}

	// -------------------------- 兜底处理（复杂切片/数组） --------------------------
	// 若上述类型均不匹配（如 []struct、数组 [5]int 等），通过反射处理
	default:
		var (
			rv   = reflect.ValueOf(any) // 获取输入的反射值
			kind = rv.Kind()            // 获取反射类型的 Kind
		)

		// 循环解引用指针：处理指向切片/数组的指针（如 *[]struct、**[5]int）
		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		// 仅处理切片（Slice）和数组（Array）类型，其他类型返回空切片
		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()             // 获取切片/数组的长度
			slice = make([]string, count) // 创建同长度的 []string
			for i := 0; i < count; i++ {
				// 获取第 i 个元素的实际值（Interface() 转为空接口），调用 String 转换
				slice[i] = String(rv.Index(i).Interface())
			}
		}
	}

	return
}

/*  bool */

// Bool 将任意输入类型（基本类型、指针、时间、字节切片等）转换为布尔值（bool），
// 定义了统一的转换规则（如“非零即真”“非空字符串即真”），空输入（nil）返回 false，
// 复杂类型（如结构体、切片）通过反射处理，确保所有类型都能得到明确的布尔结果。
// 参数：
//
//	any: 待转换的任意类型（如 int、*string、time.Time、[]byte 等）
//
// 返回值：
//
//	bool: 转换后的布尔值，遵循“非零/非空/非nil即真”的核心规则（特殊类型如时间有单独规则）
func Bool(any interface{}) bool {
	// 处理空输入：若输入为 nil（空指针或未初始化的接口），直接返回 false
	if any == nil {
		return false
	}

	// 内部函数 toBool：定义字符串转布尔值的统一规则，避免重复代码
	// 规则：字符串非空、且不等于 "0"、且小写后不等于 "false" → 返回 true，否则 false
	// 例："1"→true、"True"→true、"false"→false、"0"→false、""→false
	toBool := func(v string) bool {
		return v != "" && v != "0" && strings.ToLower(v) != "false"
	}

	// 类型断言分支：精准匹配常见基础类型，优先于反射处理（性能更优），按类型定义转换规则
	switch v := any.(type) {
	// -------------------------- 整数类型转换（非零即真） --------------------------
	// 处理 int 类型：整数不等于 0 → true，否则 false（符合“非零即真”的通用逻辑）
	case int:
		return v != 0
	// 处理 *int 类型：指针非 nil（已在开头排除 nil），解引用后的值不等于 0 → true
	// 注：开头已判断 any != nil，故此处指针一定非 nil，无需额外判断空指针
	case *int:
		return *v != 0
	// int8、*int8、int16、*int16、int32、*int32、int64、*int64 逻辑与 int 一致：
	// 非指针类型判断值≠0，指针类型解引用后判断值≠0
	case int8:
		return v != 0
	case *int8:
		return *v != 0
	case int16:
		return v != 0
	case *int16:
		return *v != 0
	case int32:
		return v != 0
	case *int32:
		return *v != 0
	case int64:
		return v != 0
	case *int64:
		return *v != 0

	// -------------------------- 无符号整数类型转换（非零即真） --------------------------
	// uint、*uint 及其他无符号整数类型逻辑与整数一致：非零即真
	case uint:
		return v != 0
	case *uint:
		return *v != 0
	case uint8:
		return v != 0
	case *uint8:
		return *v != 0
	case uint16:
		return v != 0
	case *uint16:
		return *v != 0
	case uint32:
		return v != 0
	case *uint32:
		return *v != 0
	case uint64:
		return v != 0
	case *uint64:
		return *v != 0

	// -------------------------- 浮点数类型转换（非零即真） --------------------------
	// float32、*float32、float64、*float64 逻辑与整数一致：值≠0 → true（注意：浮点数精度问题不额外处理，直接判等）
	case float32:
		return v != 0
	case *float32:
		return *v != 0
	case float64:
		return v != 0
	case *float64:
		return *v != 0

	// -------------------------- 复数类型转换（基于字符串转译） --------------------------
	// 复数类型无直接“非零”判断标准，故先调用 String() 转为字符串（如 "(1+2i)"），再用 toBool 规则判断
	// 例："(0+0i)"→字符串判空/判"0"→false；"(1+0i)"→字符串非空非"0"→true
	case complex64:
		return toBool(String(v))
	case *complex64:
		return toBool(String(*v))
	case complex128:
		return toBool(String(v))
	case *complex128:
		return toBool(String(*v))

	// -------------------------- 布尔类型转换（直接返回/解引用） --------------------------
	// 原生 bool 类型：直接返回原值（无需转换）
	case bool:
		return v
	// *bool 类型：解引用后返回原值（指针非 nil，开头已排除）
	case *bool:
		return *v

	// -------------------------- 字符串类型转换（按 toBool 规则） --------------------------
	// 原生 string 类型：调用内部函数 toBool 判断（非空、非"0"、非"false"→true）
	case string:
		return toBool(v)
	// *string 类型：解引用后调用 toBool 判断
	case *string:
		return toBool(*v)

	// -------------------------- 字节切片类型转换（转字符串后判断） --------------------------
	// []byte 类型：先通过 unsafe.Pointer 零拷贝转为 string（避免内存拷贝），再用 toBool 判断
	// 例：[]byte("1")→"1"→true；[]byte("0")→"0"→false；[]byte("")→""→false
	case []byte:
		return toBool(*(*string)(unsafe.Pointer(&v)))
	// *[]byte 类型：先解引用获取 []byte，再转 string 用 toBool 判断
	case *[]byte:
		return toBool(*(*string)(unsafe.Pointer(v)))

	// -------------------------- 时间类型转换（零时间判断） --------------------------
	// 特殊规则：time.Time 类型判断是否为“零时间”（time.Time{}，表示未初始化的时间）
	// 零时间返回 true，非零时间返回 false（与“非零即真”逻辑相反，需特别注意）
	// 例：time.Now()（非零）→false；time.Time{}（零时间）→true
	case time.Time:
		return v.IsZero()
	case *time.Time:
		return v.IsZero()

	// -------------------------- 兜底处理（复杂类型，通过反射） --------------------------
	// 若上述类型均不匹配（如自定义结构体、切片、map、chan 等），通过反射按“类型大类”制定规则
	default:
		var (
			rv   = reflect.ValueOf(any) // 获取输入的反射值（含类型和数据的“万能句柄”）
			kind = rv.Kind()            // 获取反射类型的“大类”（如 Ptr、Struct、Slice 等，非具体类型）
		)

		// 循环解引用指针：若输入是指针（或多层指针，如 **int、*[]string），一直解引用到非指针类型
		// 例：*(*Struct) → *Struct → Struct，确保后续处理的是“实际数据类型”而非指针
		for kind == reflect.Ptr {
			rv = rv.Elem()   // 解引用：获取指针指向的实际值（如 *int → int）
			kind = rv.Kind() // 更新类型大类，判断是否还需继续解引用
		}

		// 根据解引用后的“类型大类”，制定不同的布尔转换规则
		switch kind {
		case reflect.Bool: // 布尔类型：直接获取反射值的布尔结果
			return rv.Bool()
		case reflect.String: // 字符串类型：转成 string 后用 toBool 判断
			return toBool(rv.String())
		case reflect.Uintptr: // 无符号指针类型：判断其数值是否≠0（非零即真）
			return rv.Uint() != 0
		case reflect.UnsafePointer: // 不安全指针类型：非 nil 且数值≠0 → true
			return !rv.IsNil() && uint(rv.Pointer()) != 0
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: // 整数大类：数值≠0 → true
			return rv.Int() != 0
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: // 无符号整数大类：数值≠0 → true
			return rv.Uint() != 0
		case reflect.Float32, reflect.Float64: // 浮点数大类：数值≠0 → true（不处理精度问题）
			return rv.Float() != 0
		case reflect.Complex64, reflect.Complex128: // 复数大类：转字符串后用 toBool 判断
			return toBool(String(rv.Complex()))
		case reflect.Array: // 数组类型：长度≠0 → true（数组长度固定，非空即真）
			return rv.Len() != 0
		case reflect.Slice, reflect.Map: // 切片/Map 类型：非 nil 且长度≠0 → true（避免 nil 切片/Map 误判为真）
			return !rv.IsNil() && rv.Len() != 0
		case reflect.Struct: // 结构体类型：无论成员是否为零，均返回 true（结构体本身是“有值”的，即使成员全零）
			return true
		case reflect.Chan, reflect.Func, reflect.Interface: // 通道/函数/接口类型：非 nil → true（nil 表示未初始化）
			return !rv.IsNil()
		default: // 其他未覆盖类型（如 reflect.Invalid）：返回 false（兜底，避免未知类型导致异常）
			return false
		}
	}
}

// Bools 将任意切片/数组类型（含指针指向的切片）转换为布尔值切片（[]bool），
// 核心逻辑是“循环遍历切片元素，调用 Bool 函数逐个转换”，空输入（nil）返回空切片，
// 支持基础类型切片（如 []int、[]string）、复杂切片（如 []struct），适配批量判断场景。
// 参数：
//
//	any: 待转换的切片/数组类型（如 []int、*[]float64、[][]byte 等）
//
// 返回值：
//
//	[]bool: 转换后的布尔值切片，长度与输入切片一致，每个元素对应原元素的布尔结果
func Bools(any interface{}) (slice []bool) {
	// 处理空输入：若输入为 nil（空指针或未初始化的切片），直接返回空切片
	if any == nil {
		return
	}

	// 类型断言分支：精准匹配常见切片类型，优先于反射处理（性能更优），核心逻辑均为“遍历+Bool转换”
	switch v := any.(type) {
	// -------------------------- 整数切片转换（示例：[]int，其他整数切片逻辑一致） --------------------------
	// 处理 []int 类型：
	// 1. 创建与输入切片长度相同的 []bool（预分配容量，避免循环中动态扩容的性能开销）；
	// 2. 循环遍历每个 int 元素，调用 Bool 函数转换（规则：v[i] != 0 → true）；
	// 3. 将转换结果存入 []bool 切片，最终返回。
	case []int:
		slice = make([]bool, len(v)) // 预分配长度为 len(v) 的切片
		for i := range v {
			slice[i] = Bool(v[i]) // 逐个元素调用 Bool 转换
		}
	// 处理 *[]int 类型：
	// 逻辑与 []int 一致，仅多一步“解引用获取切片”（因输入是指向切片的指针）
	case *[]int:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}

	// -------------------------- 其他整数切片（逻辑同 []int，简要注释） --------------------------
	// []int8、*[]int8、[]int16、*[]int16 等：解引用（若为指针）→ 预分配切片 → 循环调用 Bool
	case []int8:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]int8:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}
	case []int16:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]int16:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}
	case []int32:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]int32:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}
	case []int64:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]int64:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}

	// -------------------------- 无符号整数切片（逻辑同 []int，简要注释） --------------------------
	// []uint、*[]uint 等：解引用（若为指针）→ 预分配切片 → 循环调用 Bool（规则：v[i] != 0 → true）
	case []uint:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]uint:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}
	case []uint8:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]uint8:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}
	case []uint16:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]uint16:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}
	case []uint32:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]uint32:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}
	case []uint64:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]uint64:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}

	// -------------------------- 浮点数切片（逻辑同 []int，简要注释） --------------------------
	// []float32、*[]float32 等：解引用（若为指针）→ 预分配切片 → 循环调用 Bool（规则：v[i] != 0 → true）
	case []float32:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]float32:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}
	case []float64:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]float64:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}

	// -------------------------- 复数切片（逻辑同 []int，简要注释） --------------------------
	// []complex64、*[]complex64 等：解引用（若为指针）→ 预分配切片 → 循环调用 Bool（转字符串后判断）
	case []complex64:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]complex64:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}
	case []complex128:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]complex128:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}

	// -------------------------- 字符串切片（逻辑同 []int，简要注释） --------------------------
	// []string、*[]string：解引用（若为指针）→ 预分配切片 → 循环调用 Bool（按 toBool 规则判断）
	case []string:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]string:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}

	// -------------------------- 布尔切片（直接返回/解引用） --------------------------
	// []bool 类型：无需转换，直接返回原值（因元素已为 bool）
	case []bool:
		return v
	// *[]bool 类型：解引用后返回原值（指针非 nil，开头已排除）
	case *[]bool:
		return *v

	// -------------------------- 空接口切片（逻辑同 []int，简要注释） --------------------------
	// []interface{}、*[]interface{}：解引用（若为指针）→ 预分配切片 → 循环调用 Bool（适配任意元素类型）
	case []interface{}:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[]interface{}:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}

	// -------------------------- 二维字节切片（逻辑同 []int，简要注释） --------------------------
	// [][]byte、*[][]byte：解引用（若为指针）→ 预分配切片 → 循环调用 Bool（每个 []byte 转 string 后判断）
	case [][]byte:
		slice = make([]bool, len(v))
		for i := range v {
			slice[i] = Bool(v[i])
		}
	case *[][]byte:
		slice = make([]bool, len(*v))
		for i := range *v {
			slice[i] = Bool((*v)[i])
		}

	// -------------------------- 兜底处理（复杂切片/数组，通过反射） --------------------------
	// 若上述类型均不匹配（如 []User、[5]int 等自定义切片/数组），通过反射处理
	default:
		var (
			rv   = reflect.ValueOf(any) // 获取输入的反射值
			kind = rv.Kind()            // 获取类型大类
		)

		// 循环解引用指针：处理指向切片/数组的指针（如 *[]User、**[5]int）
		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		// 仅处理“切片（Slice）”和“数组（Array）”类型，其他类型返回空切片
		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()           // 获取切片/数组的长度
			slice = make([]bool, count) // 预分配与原长度相同的 []bool
			for i := 0; i < count; i++ {
				// 获取第 i 个元素的空接口形式（Interface() 方法），调用 Bool 转换
				slice[i] = Bool(rv.Index(i).Interface())
			}
		}
	}

	return
}

// BoolPointer 先调用 Bool 函数将任意类型转为布尔值（bool），再返回该布尔值的指针（*bool），
// 适配需要传入布尔值指针的场景（如函数参数要求 *bool、结构体字段为 *bool、JSON 反序列化等），
// 空输入或转换后为 false 均返回对应布尔值的指针，不会返回 nil 指针。
// 参数：
//
//	any: 待转换的任意类型（同 Bool 函数的输入，如 int、*string、[]byte 等）
//
// 返回值：
//
//	*bool: 转换后布尔值的指针，指针指向的内容为 Bool(any) 的结果（true 或 false）
func BoolPointer(any interface{}) *bool {
	v := Bool(any) // 复用 Bool 函数的转换逻辑，得到布尔值
	return &v      // 取布尔值的地址，返回指针（注意：v 是局部变量，函数返回后地址仍有效，Go 会自动处理内存）
}

// BoolsPointer 先调用 Bools 函数将任意切片转为布尔值切片（[]bool），再返回该切片的指针（*[]bool），
// 适配需要传入布尔值切片指针的场景（如函数参数要求 *[]bool、结构体字段为 *[]bool 等），
// 空输入返回指向空切片的指针，不会返回 nil 指针。
// 参数：
//
//	any: 待转换的任意切片/数组类型（同 Bools 函数的输入，如 []int、*[]string 等）
//
// 返回值：
//
//	*[]bool: 转换后布尔值切片的指针，指针指向的内容为 Bools(any) 的结果（[]bool 切片）
func BoolsPointer(any interface{}) *[]bool {
	v := Bools(any) // 复用 Bools 函数的转换逻辑，得到布尔值切片
	return &v       // 取切片的地址，返回指针（切片是引用类型，指针指向切片头，底层数组内存安全）
}

/* uint */
func Uint(any interface{}) uint {
	return uint(Uint64(any))
}

// Uints 任何类型转uint切片
func Uints(any interface{}) (slice []uint) {
	if any == nil {
		return
	}

	switch v := any.(type) {
	case []int:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]int:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []int8:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]int8:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []int16:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]int16:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []int32:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]int32:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []int64:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]int64:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []uint:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]uint:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []uint8:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]uint8:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []uint16:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]uint16:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []uint32:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]uint32:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []uint64:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]uint64:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []float32:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]float32:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []float64:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]float64:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []complex64:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]complex64:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []complex128:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]complex128:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []string:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]string:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []bool:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]bool:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case []interface{}:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[]interface{}:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	case [][]byte:
		slice = make([]uint, len(v))
		for i := range v {
			slice[i] = Uint(v[i])
		}
	case *[][]byte:
		slice = make([]uint, len(*v))
		for i := range *v {
			slice[i] = Uint((*v)[i])
		}
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()
			slice = make([]uint, count)
			for i := 0; i < count; i++ {
				slice[i] = Uint(rv.Index(i).Interface())
			}
		}
	}

	return
}

func UintPointer(any interface{}) *uint {
	v := Uint(any)
	return &v
}

func UintsPointer(any interface{}) *[]uint {
	v := Uints(any)
	return &v
}

/* uint8 */

func Uint8(any interface{}) uint8 {
	return uint8(Uint64(any))
}

func Uint8s(any interface{}) (slice []uint8) {
	if any == nil {
		return
	}

	switch v := any.(type) {
	case []int:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]int:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []int8:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]int8:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []int16:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]int16:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []int32:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]int32:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []int64:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]int64:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []uint:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]uint:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []uint8:
		return v
	case *[]uint8:
		return *v
	case []uint16:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]uint16:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []uint32:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]uint32:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []uint64:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]uint64:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []float32:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]float32:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []float64:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]float64:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []complex64:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]complex64:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []complex128:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]complex128:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []string:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]string:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []bool:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]bool:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case []interface{}:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[]interface{}:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	case [][]byte:
		slice = make([]uint8, len(v))
		for i := range v {
			slice[i] = Uint8(v[i])
		}
	case *[][]byte:
		slice = make([]uint8, len(*v))
		for i := range *v {
			slice[i] = Uint8((*v)[i])
		}
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()
			slice = make([]uint8, count)
			for i := 0; i < count; i++ {
				slice[i] = Uint8(rv.Index(i).Interface())
			}
		}
	}

	return
}

func Uint8Pointer(any interface{}) *uint8 {
	v := Uint8(any)
	return &v
}

func Uint8sPointer(any interface{}) *[]uint8 {
	v := Uint8s(any)
	return &v
}

/* uint16 */

func Uint16(any interface{}) uint16 {
	return uint16(Uint64(any))
}

func Uint16s(any interface{}) (slice []uint16) {
	if any == nil {
		return
	}

	switch v := any.(type) {
	case []int:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]int:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []int8:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]int8:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []int16:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]int16:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []int32:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]int32:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []int64:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]int64:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []uint:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]uint:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []uint8:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]uint8:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []uint16:
		return v
	case *[]uint16:
		return *v
	case []uint32:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]uint32:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []uint64:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]uint64:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []float32:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]float32:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []float64:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]float64:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []complex64:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]complex64:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []complex128:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]complex128:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []string:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]string:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []bool:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]bool:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case []interface{}:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[]interface{}:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	case [][]byte:
		slice = make([]uint16, len(v))
		for i := range v {
			slice[i] = Uint16(v[i])
		}
	case *[][]byte:
		slice = make([]uint16, len(*v))
		for i := range *v {
			slice[i] = Uint16((*v)[i])
		}
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()
			slice = make([]uint16, count)
			for i := 0; i < count; i++ {
				slice[i] = Uint16(rv.Index(i).Interface())
			}
		}
	}

	return
}

func Uint16Pointer(any interface{}) *uint16 {
	v := Uint16(any)
	return &v
}

func Uint16sPointer(any interface{}) *[]uint16 {
	v := Uint16s(any)
	return &v
}

/* uint32 */

func Uint32(any interface{}) uint32 {
	return uint32(Uint64(any))
}

func Uint32s(any interface{}) (slice []uint32) {
	if any == nil {
		return
	}

	switch v := any.(type) {
	case []int:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]int:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []int8:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]int8:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []int16:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]int16:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []int32:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]int32:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []int64:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]int64:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []uint:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]uint:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []uint8:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]uint8:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []uint16:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]uint16:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []uint32:
		return v
	case *[]uint32:
		return *v
	case []uint64:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]uint64:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []float32:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]float32:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []float64:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]float64:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []complex64:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]complex64:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []complex128:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]complex128:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []string:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]string:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []bool:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]bool:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case []interface{}:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[]interface{}:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	case [][]byte:
		slice = make([]uint32, len(v))
		for i := range v {
			slice[i] = Uint32(v[i])
		}
	case *[][]byte:
		slice = make([]uint32, len(*v))
		for i := range *v {
			slice[i] = Uint32((*v)[i])
		}
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()
			slice = make([]uint32, count)
			for i := 0; i < count; i++ {
				slice[i] = Uint32(rv.Index(i).Interface())
			}
		}
	}

	return
}

func Uint32Pointer(any interface{}) *uint32 {
	v := Uint32(any)
	return &v
}

func Uint32sPointer(any interface{}) *[]uint32 {
	v := Uint32s(any)
	return &v
}

/* uint64 */

func Uint64(any interface{}) uint64 {
	if any == nil {
		return 0
	}

	switch v := any.(type) {
	case int:
		return uint64(v)
	case *int:
		return uint64(*v)
	case int8:
		return uint64(v)
	case *int8:
		return uint64(*v)
	case int16:
		return uint64(v)
	case *int16:
		return uint64(*v)
	case int32:
		return uint64(v)
	case *int32:
		return uint64(*v)
	case int64:
		return uint64(v)
	case *int64:
		return uint64(*v)
	case uint:
		return uint64(v)
	case *uint:
		return uint64(*v)
	case uint8:
		return uint64(v)
	case *uint8:
		return uint64(*v)
	case uint16:
		return uint64(v)
	case *uint16:
		return uint64(*v)
	case uint32:
		return uint64(v)
	case *uint32:
		return uint64(*v)
	case uint64:
		return v
	case *uint64:
		return *v
	case float32:
		return uint64(v)
	case *float32:
		return uint64(*v)
	case float64:
		return uint64(v)
	case *float64:
		return uint64(*v)
	case complex64:
		return uint64(real(v))
	case *complex64:
		return uint64(real(*v))
	case complex128:
		return uint64(real(v))
	case *complex128:
		return uint64(real(*v))
	case bool:
		if v {
			return 1
		}
		return 0
	case *bool:
		if *v {
			return 1
		}
		return 0
	case time.Time:
		return uint64(v.UnixNano())
	case *time.Time:
		return uint64(v.UnixNano())
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Bool:
			return Uint64(rv.Bool())
		case reflect.String:
			i, _ := strconv.ParseUint(rv.String(), 0, 64)
			return i
		case reflect.Uintptr:
			return rv.Uint()
		case reflect.UnsafePointer:
			return uint64(rv.Pointer())
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			return Uint64(rv.Int())
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			return rv.Uint()
		case reflect.Float32, reflect.Float64:
			return uint64(rv.Float())
		case reflect.Complex64, reflect.Complex128:
			return uint64(real(rv.Complex()))
		default:
			return 0
		}
	}
}

func Uint64s(any interface{}) (slice []uint64) {
	if any == nil {
		return
	}

	switch v := any.(type) {
	case []int:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]int:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []int8:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]int8:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []int16:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]int16:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []int32:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]int32:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []int64:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]int64:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []uint:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]uint:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []uint8:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]uint8:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []uint16:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]uint16:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []uint32:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]uint32:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []uint64:
		return v
	case *[]uint64:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []float32:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]float32:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []float64:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]float64:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []complex64:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]complex64:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []complex128:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]complex128:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []string:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]string:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []bool:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]bool:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case []interface{}:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[]interface{}:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	case [][]byte:
		slice = make([]uint64, len(v))
		for i := range v {
			slice[i] = Uint64(v[i])
		}
	case *[][]byte:
		slice = make([]uint64, len(*v))
		for i := range *v {
			slice[i] = Uint64((*v)[i])
		}
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()
			slice = make([]uint64, count)
			for i := 0; i < count; i++ {
				slice[i] = Uint64(rv.Index(i).Interface())
			}
		}
	}

	return
}

func Uint64Pointer(any interface{}) *uint64 {
	v := Uint64(any)
	return &v
}

func Uint64sPointer(any interface{}) *[]uint64 {
	v := Uint64s(any)
	return &v
}

/* rune */

// Rune 将任意类型值转换为单个 rune（底层为 int32，代表 Unicode 码点）
// 转换规则：
// 1. 数字类型：直接截断为 int32 范围（超出范围时按 Go 类型转换规则处理）
// 2. 布尔类型：true → 1（对应 Unicode 码点 U+0001），false → 0（U+0000）
// 3. 时间类型：取 Unix 时间戳（秒级），再转换为 rune（适合时间相关的简化标识）
// 4. 字符串：取第一个字符的 rune（空字符串返回 0）
// 5. 字节切片：按 UTF-8 解码为字符串后，取第一个字符的 rune（解码失败返回 0）
// 6. 指针类型：自动解引用后按对应基础类型处理
// 7. 其他未明确类型：返回 0（U+0000，空字符）
func Rune(any interface{}) rune {
	if any == nil {
		return 0
	}

	switch v := any.(type) {
	// 有符号整数类型
	case int:
		return rune(v)
	case *int:
		return rune(*v)
	case int8:
		return rune(v)
	case *int8:
		return rune(*v)
	case int16:
		return rune(v)
	case *int16:
		return rune(*v)
	case int32:
		return rune(v)
	case *int32:
		return rune(*v)
	case int64:
		return rune(v) // 超出 int32 范围时自动截断
	case *int64:
		return rune(*v)

	// 无符号整数类型
	case uint:
		return rune(v)
	case *uint:
		return rune(*v)
	case uint8:
		return rune(v)
	case *uint8:
		return rune(*v)
	case uint16:
		return rune(v)
	case *uint16:
		return rune(*v)
	case uint32:
		return rune(v)
	case *uint32:
		return rune(*v)
	case uint64:
		return rune(v) // 超出 int32 范围时自动截断
	case *uint64:
		return rune(*v)

	// 浮点类型：取整数部分转换（丢弃小数）
	case float32:
		return rune(v)
	case *float32:
		return rune(*v)
	case float64:
		return rune(v)
	case *float64:
		return rune(*v)

	// 复数类型：取实部的整数部分转换
	case complex64:
		return rune(real(v))
	case *complex64:
		return rune(real(*v))
	case complex128:
		return rune(real(v))
	case *complex128:
		return rune(real(*v))

	// 布尔类型
	case bool:
		if v {
			return 1
		}
		return 0
	case *bool:
		if *v {
			return 1
		}
		return 0

	// 时间类型：取 Unix 秒级时间戳
	case time.Time:
		return rune(v.Unix())
	case *time.Time:
		return rune(v.Unix())

	// 字符串类型：取第一个字符的 rune
	case string:
		if v == "" {
			return 0
		}
		r, _ := utf8.DecodeRuneInString(v)
		return r

	// 字节切片：按 UTF-8 解码后取第一个 rune
	case []byte:
		if len(v) == 0 {
			return 0
		}
		r, _ := utf8.DecodeRune(v)
		return r
	case *[]byte:
		return Rune(*v)

	// 其他类型：通过反射处理
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		// 循环解引用指针
		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Bool:
			return Rune(rv.Bool())
		case reflect.String:
			return Rune(rv.String())
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			return rune(rv.Int())
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
			return rune(rv.Uint())
		case reflect.Float32, reflect.Float64:
			return rune(rv.Float())
		case reflect.Complex64, reflect.Complex128:
			return rune(real(rv.Complex()))
		default:
			return 0
		}
	}
}

// Runes 将任意类型的切片/数组转换为 []rune
// 转换规则：
// 1. 直接支持各种基础类型切片（及切片指针），循环调用 Rune() 转换每个元素
// 2. 支持 interface{} 切片，按元素实际类型转换
// 3. 支持数组类型（通过反射处理）
// 4. 空切片/ nil 输入返回空 []rune
func Runes(any interface{}) (slice []rune) {
	if any == nil {
		return
	}

	switch v := any.(type) {
	// 有符号整数切片
	case []int:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]int:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []int8:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]int8:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []int16:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]int16:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []int32:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]int32:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []int64:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]int64:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}

	// 无符号整数切片
	case []uint:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]uint:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []uint8:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]uint8:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []uint16:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]uint16:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []uint32:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]uint32:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []uint64:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]uint64:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}

	// 浮点/复数切片
	case []float32:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]float32:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []float64:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]float64:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []complex64:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]complex64:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []complex128:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]complex128:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}

	// 字符串/布尔/字节切片
	case []string:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]string:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case []bool:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]bool:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}
	case [][]byte:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[][]byte:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}

	// interface{} 切片
	case []interface{}:
		slice = make([]rune, len(v))
		for i := range v {
			slice[i] = Rune(v[i])
		}
	case *[]interface{}:
		slice = make([]rune, len(*v))
		for i := range *v {
			slice[i] = Rune((*v)[i])
		}

	// 其他类型：通过反射处理数组/切片
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		// 循环解引用指针
		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		// 处理数组或切片
		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()
			slice = make([]rune, count)
			for i := 0; i < count; i++ {
				slice[i] = Rune(rv.Index(i).Interface())
			}
		}
	}

	return
}

// RunePointer 将任意类型值转换为 *rune（指向转换后的 rune 值）
func RunePointer(any interface{}) *rune {
	v := Rune(any)
	return &v
}

// RunesPointer 将任意类型的切片/数组转换为 *[]rune（指向转换后的 []rune）
func RunesPointer(any interface{}) *[]rune {
	v := Runes(any)
	return &v
}

/* json */

// Json 将任意类型值转换为JSON格式字符串
// 转换规则：
// 1. 优先检查输入是否已为JSON格式（string/*string/[]byte/*[]byte类型），若是则直接返回
// 2. 对非JSON原始类型，通过反射识别可序列化类型（map/array/slice/struct），使用json.Marshal序列化
// 3. 不支持序列化的类型（如int、bool等基础类型、nil等）返回空字符串
// @param any 待转换的任意类型值
// @return string 转换后的JSON字符串，转换失败或不支持的类型返回空字符串
func Json(any interface{}) string {
	// isJson 是内部辅助函数，判断输入字符串是否符合JSON格式（对象或数组）
	// 核心逻辑：字符串长度至少2字节，且首尾分别为"{}"（JSON对象）或"[]"（JSON数组）
	isJson := func(s string) bool {
		l := len(s) // 获取字符串长度，存到变量l（减少重复计算）
		// 逻辑判断：长度≥2，且（首字符是'{'且尾字符是'}'） 或 （首字符是'['且尾字符是']'）
		return l >= 2 && ((s[0] == '{' && s[l-1] == '}') || (s[0] == '[' && s[l-1] == ']'))
	}

	// 第一步：通过类型断言处理常见的"可能已为JSON"的类型，避免不必要的反射/序列化
	switch v := any.(type) {
	// 处理string类型：直接检查是否为JSON格式，是则返回原字符串
	case string:
		if isJson(v) {
			return v
		}
	// 处理*string类型：解引用后检查是否为JSON格式，是则返回解引用后的字符串
	case *string:
		if isJson(*v) {
			return *v
		}
	// 处理[]byte类型：先转成字符串（调用BytesToString无拷贝转换），再检查是否为JSON，是则返回
	case []byte:
		if s := BytesToString(v); isJson(s) {
			return s
		}
	// 处理*[]byte类型：解引用后转字符串，检查是否为JSON，是则返回
	case *[]byte:
		if s := BytesToString(*v); isJson(s) {
			return s
		}
	// 第二步：处理上述类型之外的情况，通过反射识别可序列化类型
	default:
		var (
			rv   = reflect.ValueOf(any) // 获取输入值的反射对象（reflect.Value），用于后续类型分析
			kind = rv.Kind()            // 获取反射对象的类型（如Ptr、Map、Struct等），存到变量kind
		)

		// 循环解引用指针：若输入是指针类型（如*struct、**map），则不断取其指向的实际元素，直到非指针类型
		// 目的：统一处理"值类型"和"指针类型"（如struct和*struct都能被正确序列化）
		for kind == reflect.Ptr {
			rv = rv.Elem()   // 解引用指针，获取指向的元素（如*struct→struct）
			kind = rv.Kind() // 更新元素的类型，用于下一次循环判断
		}

		// 根据解引用后的实际类型，判断是否支持JSON序列化
		switch kind {
		// 处理string类型（反射识别的情况，如interface{}中存的string）：检查是否为JSON，是则返回
		case reflect.String:
			if s := rv.String(); isJson(s) {
				return s
			}
		// 处理可被json.Marshal序列化的核心类型：map/array/slice/struct
		// 这些类型是JSON支持的基础结构（对象、数组），调用标准库json.Marshal序列化
		case reflect.Map, reflect.Array, reflect.Slice, reflect.Struct:
			// 调用json.Marshal序列化：将输入值转成JSON字节切片，若无错误则转成字符串返回
			if b, err := json.Marshal(v); err == nil {
				return BytesToString(b)
			}
			// 其他类型（如int、bool、float等基础类型，或chan、func等不支持序列化的类型）：不处理，返回空字符串
		}
	}

	// 所有不满足条件的情况（如基础类型、序列化失败、nil等）：返回空字符串
	return ""
}

/* unsafe convert string and bytes */

// StringToBytes 将字符串无拷贝转换为字节切片（[]byte）
// 实现原理：利用Go中string和[]byte的底层结构共性（均包含Data指针和Len长度），
// 通过unsafe.Pointer直接转换结构体指针，避免内存拷贝，大幅提升性能
// 注意事项：
// 1. 转换后的[]byte不可修改！因为string在Go中是不可变的，修改字节切片会破坏string的不可变性，导致运行时panic
// 2. 仅在性能敏感场景使用（如大量数据转换），普通场景建议使用[]byte(s)（安全但有拷贝）
// @param s 待转换的字符串
// @return []byte 转换后的字节切片，与原字符串共享底层内存
func StringToBytes(s string) (b []byte) {
	// 1. 将string变量s的地址转为unsafe.Pointer，再强转为*reflect.StringHeader
	// reflect.StringHeader是string的底层结构：包含Data（指向字符数据的指针）和Len（字符串长度）
	sh := (*reflect.StringHeader)(unsafe.Pointer(&s))

	// 2. 将字节切片变量b的地址转为unsafe.Pointer，再强转为*reflect.SliceHeader
	// reflect.SliceHeader是[]byte的底层结构：包含Data（指向字节数据的指针）、Len（切片长度）、Cap（切片容量）
	bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))

	// 3. 复制底层数据指针和长度：让字节切片的Data指向字符串的Data，Len与字符串一致
	// 此时b与s共享同一块内存，无拷贝开销
	bh.Data = sh.Data // 字节切片的数据指针 = 字符串的数据指针
	bh.Len = sh.Len   // 字节切片的长度 = 字符串的长度
	bh.Cap = sh.Len   // 字节切片的容量 = 长度（因字符串不可修改，容量无需大于长度）
	return            // 返回初始化后的字节切片b
}

// BytesToString 将字节切片（[]byte）无拷贝转换为字符串（string）
// 实现原理与StringToBytes对称：复用字节切片的底层内存，通过转换结构体指针实现无拷贝
// 注意事项：
// 1. 若原字节切片后续被修改，转换后的字符串也会"被修改"（因共享内存），违反string不可变的语义，需避免
// 2. 确保字节切片的内存在字符串生命周期内有效（如不使用栈上临时切片转换后长期持有字符串）
// @param b 待转换的字节切片
// @return string 转换后的字符串，与原字节切片共享底层内存
func BytesToString(b []byte) (s string) {
	// 1. 将字节切片变量b的地址转为unsafe.Pointer，强转为*reflect.SliceHeader，获取底层Data和Len
	bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))

	// 2. 将字符串变量s的地址转为unsafe.Pointer，强转为*reflect.StringHeader
	sh := (*reflect.StringHeader)(unsafe.Pointer(&s))

	// 3. 复制数据指针和长度：让字符串的Data指向字节切片的Data，Len与字节切片一致
	// 此时s与b共享同一块内存，无拷贝开销
	sh.Data = bh.Data // 字符串的数据指针 = 字节切片的数据指针
	sh.Len = bh.Len   // 字符串的长度 = 字节切片的长度
	return            // 返回初始化后的字符串s（无需处理Cap，因string无容量概念）
}

/* interface */

//// Int 用于将任意类型的输入值转换为int类型
//// 功能说明：
////  1. 支持常见整数类型（int/int8/int16/int32/int64/uint/uint8/uint16/uint32/uint64）的转换
////  2. 若输入为nil或非整数类型，返回0
//// 参数：
////  v - 待转换的任意类型值（interface{}）
//// 返回值：
////  int - 转换后的int值；转换失败时返回0
//func Int(v interface{}) int {
//	// 处理输入为nil的情况：直接返回0
//	if v == nil {
//		return 0
//	}
//
//	// 通过反射获取输入值的反射对象（reflect.Value）
//	// 反射可以在运行时获取变量的类型和值，这里用于处理任意类型的整数转换
//	rv := reflect.ValueOf(v)
//
//	// 根据反射对象的具体类型（Kind）进行类型转换
//	// 不同整数类型的反射值需要调用不同的方法获取原始值（Int()用于有符号整数，Uint()用于无符号整数）
//	switch rv.Kind() {
//	// 处理有符号整数类型
//	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
//		// 调用Int()方法获取反射值对应的int64，再转换为int返回
//		return int(rv.Int())
//	// 处理无符号整数类型
//	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
//		// 调用Uint()方法获取反射值对应的uint64，再转换为int返回
//		return int(rv.Uint())
//	// 非整数类型：直接返回0
//	default:
//		return 0
//	}
//}

// Interfaces 用于将输入的切片、数组或其指针转换为[]interface{}类型
// 功能说明：
//  1. 支持直接输入切片/数组，或指向切片/数组的指针（会自动解引用指针）
//  2. 转换后的切片元素为原容器元素经Int()函数处理后的int值
//  3. 若输入为nil、非容器类型（如字符串、结构体等），返回空的[]interface{}（nil）
//
// 参数：
//
//	any - 待转换的任意类型值（支持切片、数组及其指针）
//
// 返回值：
//
//	[]interface{} - 转换后的接口切片；转换失败时返回nil
func Interfaces(any interface{}) (slice []interface{}) {
	// 第一步：处理输入为nil的情况
	// 若输入是nil（如var s []int = nil），直接返回空切片（初始值为nil）
	if any == nil {
		return
	}

	// 第二步：初始化反射对象，获取输入值的类型信息
	// 声明两个变量：
	//   rv：存储输入值的反射值（reflect.Value），用于后续操作值
	//   kind：存储rv的具体类型（reflect.Kind），用于判断类型
	var (
		rv   = reflect.ValueOf(any) // 通过reflect.ValueOf获取输入值的反射对象
		kind = rv.Kind()            // 通过Kind()方法获取反射对象的类型（如ptr、slice、array等）
	)

	// 第三步：循环解引用指针，直到获取非指针类型
	// 原因：输入可能是指向切片/数组的指针（如*[]int、**[3]int），需要先获取指针指向的实际容器
	// 执行逻辑：
	//   若当前类型是指针（reflect.Ptr），则通过Elem()方法获取指针指向的元素
	//   更新rv为指向的元素，同时更新kind为新元素的类型
	//   重复上述过程，直到kind不是指针类型
	for kind == reflect.Ptr {
		rv = rv.Elem()   // 解引用指针，获取指向的元素（如*[]int -> []int）
		kind = rv.Kind() // 更新类型为新元素的类型
	}

	// 第四步：判断解引用后的类型是否为切片或数组，仅处理这两种容器类型
	switch kind {
	// 若类型是切片（reflect.Slice）或数组（reflect.Array）
	case reflect.Slice, reflect.Array:
		// 4.1 获取容器的长度（元素数量）
		count := rv.Len()

		// 4.2 初始化结果切片，长度与原容器一致
		slice = make([]interface{}, count)

		// 4.3 遍历原容器的每个元素，转换后存入结果切片
		for i := 0; i < count; i++ {
			// 步骤分解：
			// 1. rv.Index(i)：通过索引i获取容器的第i个元素（反射值）
			// 2. .Interface()：将反射值转换为interface{}类型（原始元素值）
			// 3. Int(...)：调用Int()函数将元素转换为int类型
			// 4. 存入结果切片的第i个位置
			slice[i] = Int(rv.Index(i).Interface())
			// 适应 “处理整数集合” 的场景，避免因原始类型多样导致的后续处理复杂
			// 这里不直接用interface，应该是又后续原因
		}
		// 若类型不是切片/数组（如字符串、int、结构体等），不做处理，保持slice为nil
	}

	// 第五步：返回转换结果
	// 若输入是切片/数组（或其指针），返回转换后的[]interface{}
	// 其他情况返回nil
	return
}

// InterfacesPointer 用于获取Interfaces()转换结果的指针
// 功能说明：
//  1. 先调用Interfaces()函数获取转换后的[]interface{}
//  2. 返回该切片的指针（*[]interface{}）
//
// 参数：
//
//	any - 待转换的任意类型值（同Interfaces()参数要求）
//
// 返回值：
//
//	*[]interface{} - 转换后的接口切片的指针；若Interfaces()返回nil，指针指向nil切片
func InterfacesPointer(any interface{}) *[]interface{} {
	// 第一步：调用Interfaces()函数进行转换，得到[]interface{}类型的结果
	v := Interfaces(any)

	// 第二步：返回结果切片的指针
	return &v
}

/* int64 */

// Int64 核心功能：将任意支持类型的单个值转换为 int64 类型
// 设计意图：提供统一的类型转换入口，覆盖常见基础类型、指针类型及特殊类型（时间、字节切片），避免类型转换冗余代码
// 功能特性：
//  1. 输入为 nil 时返回 0，避免空指针 panic
//  2. 支持指针类型自动解引用（如 *int → int → int64）
//  3. 特殊类型处理：time.Time 转时间戳（纳秒级）、[]byte 按大端序解析为 int64
//  4. 不支持类型（如结构体）返回 0，保证函数安全性
//
// 参数：
//
//	any - 待转换的任意类型值（支持基础类型、指针、time.Time、[]byte 等）
//
// 返回值：
//
//	int64 - 转换后的 int64 值；不支持类型或转换失败时返回 0
func Int64(any interface{}) int64 {
	// 第一步：处理输入为 nil 的场景
	// 若输入是 nil（如 var x *int = nil），直接返回 0，避免后续类型断言/反射报错
	if any == nil {
		return 0
	}

	// 第二步：优先通过「类型断言」处理常见类型（效率高于反射）
	// 类型断言语法：any.(type) 仅能在 switch 中使用，匹配变量的具体类型
	switch v := any.(type) {
	// --------------- 处理有符号整数及指针 ---------------
	case int:
		// 直接将 int 转为 int64（注意：32位系统中 int 是 32位，转 int64 无溢出风险）
		return int64(v)
	case *int:
		// 先解引用指针（*v 获取指针指向的 int 值），再转 int64
		return int64(*v)
	case int8:
		// int8（-128~127）范围远小于 int64，直接转换无风险
		return int64(v)
	case *int8:
		return int64(*v)
	case int16:
		return int64(v)
	case *int16:
		return int64(*v)
	case int32:
		// int32（-2^31~2^31-1）转 int64 无溢出
		return int64(v)
	case *int32:
		return int64(*v)
	case int64:
		// 类型一致，直接返回原值（无需转换，提高效率）
		return v
	case *int64:
		return *v

	// --------------- 处理无符号整数及指针 ---------------
	case uint:
		// uint 是无符号类型，转 int64 需注意：若 uint 是 64位（如64位系统），值超过 int64 最大值会溢出
		// 此处按 Go 语言默认规则转换，溢出时结果为截断后的二进制值
		return int64(v)
	case *uint:
		return int64(*v)
	case uint8: // 即 byte 类型
		return int64(v)
	case *uint8:
		return int64(*v)
	case uint16:
		return int64(v)
	case *uint16:
		return int64(*v)
	case uint32:
		return int64(v)
	case *uint32:
		return int64(*v)
	case uint64:
		// uint64 最大值（18446744073709551615）远超 int64 最大值（9223372036854775807），可能溢出
		return int64(v)
	case *uint64:
		return int64(*v)

	// --------------- 处理浮点数及指针（注意：浮点数转整数会截断小数部分） ---------------
	case float32:
		// 如 float32(3.9) → int64(3)，float32(-2.1) → int64(-2)
		return int64(v)
	case *float32:
		return int64(*v)
	case float64:
		return int64(v)
	case *float64:
		return int64(*v)

	// --------------- 处理复数及指针（仅取实部转换，忽略虚部） ---------------
	case complex64:
		// complex64 由两个 float32 组成（实部+虚部），real(v) 取实部
		return int64(real(v))
	case *complex64:
		return int64(real(*v))
	case complex128:
		// complex128 由两个 float64 组成，real(v) 取实部
		return int64(real(v))
	case *complex128:
		return int64(real(*v))

	// --------------- 处理布尔值及指针（约定：true→1，false→0） ---------------
	case bool:
		if v {
			return 1
		}
		return 0
	case *bool:
		if *v {
			return 1
		}
		return 0

	// --------------- 处理时间类型及指针（转纳秒级时间戳，常见于时间序列化） ---------------
	case time.Time:
		// UnixNano() 返回从 1970-01-01 00:00:00 UTC 到当前时间的纳秒数，类型为 int64
		return v.UnixNano()
	case *time.Time:
		return v.UnixNano()

	// --------------- 处理字节切片及指针（按大端序解析为 int64，常见于二进制数据解析） ---------------
	case []byte:
		/* 这里默认数组就是一种网络byte数据流 */
		/*
			输入：[]byte{0x01, 0x02, 0x03}（长度 3 字节）Int64 函数的处理步骤：
			创建 8 字节缓冲区 buf（初始为 [0,0,0,0,0,0,0,0]）；
			计算复制起始位置：len(buf) - len(byt) = 8 - 3 = 5，即从 buf[5] 开始复制输入字节；
			复制后 buf 内容为：[0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03]；
			按大端序（高位在前）解析 buf 为 int64：
			十六进制值为 0x0000000000010203，转换为十进制是 66051（计算：0x01*256² + 0x02*256 + 0x03 = 65536 + 512 + 3 = 66051）。
		*/
		// 1. 初始化 8 字节缓冲区（int64 固定占 8 字节）
		buf := make([]byte, 8)
		// 2. 从缓冲区末尾开始复制字节切片 v（若 v 长度<8，前面会自动补 0）
		// 例：v = []byte{0x01, 0x02} → buf 变为 [0,0,0,0,0,0,1,2]，符合大端序（高位在前）
		copy(buf[len(buf)-len(v):], v)

		// 3. 用 binary.Read 按大端序（BigEndian）解析 buf 为 int64
		var i int64
		if err := binary.Read(bytes.NewReader(buf), binary.BigEndian, &i); err == nil {
			return i // 解析成功，返回结果
		} else {
			return 0 // 解析失败（理论上不会触发，因 buf 长度固定为 8），返回 0
		}
	case *[]byte:
		// 解引用字节切片指针，递归调用 Int64 处理
		return Int64(*v)

	// --------------- 兜底：处理上述未覆盖的类型（用反射进一步转换） ---------------
	default:
		// 1. 初始化反射对象：获取输入值的反射值（reflect.Value）和类型（reflect.Kind）
		var (
			rv   = reflect.ValueOf(any) // 反射值：可操作变量的实际值
			kind = rv.Kind()            // 类型分类：如 ptr、bool、string 等
		)

		// 2. 循环解引用指针：若输入是多级指针（如 **int），直到获取非指针类型
		// 例：**int → *int → int，确保后续处理的是原始值类型
		for kind == reflect.Ptr {
			rv = rv.Elem()   // 解引用：获取指针指向的元素（如 *int → int 的反射值）
			kind = rv.Kind() // 更新类型，继续判断是否为指针
		}

		// 3. 根据解引用后的类型，通过反射方法获取值并转换为 int64
		switch kind {
		case reflect.Bool:
			// rv.Bool() 获取反射值对应的 bool 值，再调用 Int64 转换（复用布尔值转 1/0 的逻辑）
			return Int64(rv.Bool())
		case reflect.String:
			// 字符串转 int64：strconv.ParseInt 第三个参数 64 表示目标类型是 int64
			// 忽略错误：若字符串无法转整数（如 "abc"），ParseInt 返回 0，符合函数容错设计
			i, _ := strconv.ParseInt(rv.String(), 10, 64)
			return i
		case reflect.Uintptr:
			// Uintptr 是指针的整数表示，rv.Uint() 获取其 uint64 值，再转 int64
			return int64(rv.Uint())
		case reflect.UnsafePointer:
			// UnsafePointer 是无类型指针，rv.Pointer() 获取其 uintptr 值，再转 int64
			return int64(rv.Pointer())
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			// 有符号整数类型：rv.Int() 直接返回 int64 值（反射已处理类型适配）
			return rv.Int()
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			// 无符号整数类型：rv.Uint() 返回 uint64 值，再转 int64
			return int64(rv.Uint())
		case reflect.Float32, reflect.Float64:
			// 浮点数类型：rv.Float() 返回 float64 值，再转 int64（截断小数）
			return int64(rv.Float())
		case reflect.Complex64, reflect.Complex128:
			// 复数类型：rv.Complex() 返回 complex128 值，取实部后转 int64
			return int64(real(rv.Complex()))
		default:
			// 不支持的类型（如结构体、map、channel 等），返回 0
			return 0
		}
	}
}

// Int64s 核心功能：将输入的「切片/数组」（含指针）转换为 []int64 类型
// 设计意图：统一处理各类基础类型切片/数组，自动转换为 int64 切片，避免重复遍历逻辑
// 功能特性：
//  1. 支持直接切片（如 []int）、切片指针（如 *[]int）、数组（如 [3]int）
//  2. 每个元素通过 Int64() 转换，保证类型统一为 int64
//  3. 输入为 nil 或非容器类型时，返回空的 []int64（nil）
//
// 参数：
//
//	any - 待转换的容器类型（支持切片、数组及其指针，元素类型需是 Int64() 支持的类型）
//
// 返回值：
//
//	[]int64 - 转换后的 int64 切片；转换失败时返回 nil
func Int64s(any interface{}) (slice []int64) {
	// 第一步：处理输入为 nil 的场景（如 var s []int = nil），直接返回空切片
	if any == nil {
		return
	}

	// 第二步：优先通过「类型断言」处理常见切片/切片指针（效率高于反射）
	// 核心逻辑：匹配切片类型 → 初始化同等长度的 []int64 → 遍历元素调用 Int64() 转换
	switch v := any.(type) {
	// --------------- 有符号整数切片及指针 ---------------
	case []int:
		slice = make([]int64, len(v)) // 初始化结果切片，长度与输入一致
		for i := range v {
			slice[i] = Int64(v[i]) // 每个元素转 int64
		}
	case *[]int:
		slice = make([]int64, len(*v)) // 先解引用切片指针，再初始化长度
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}
	case []int8:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]int8:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}
	case []int16:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]int16:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}
	case []int32:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]int32:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}
	case []int64:
		// 类型一致，直接返回原切片（无需转换，提高效率）
		return v
	case *[]int64:
		// 解引用后直接返回，避免拷贝
		return *v

	// --------------- 无符号整数切片及指针 ---------------
	case []uint:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]uint:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}
	case []uint8: // 即 []byte
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]uint8:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}
	case []uint16:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]uint16:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}
	case []uint32:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]uint32:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}
	case []uint64:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]uint64:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}

	// --------------- 浮点数切片及指针 ---------------
	case []float32:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]float32:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}
	case []float64:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]float64:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}

	// --------------- 复数切片及指针 ---------------
	case []complex64:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]complex64:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}
	case []complex128:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i])
		}
	case *[]complex128:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}

	// --------------- 字符串切片及指针 ---------------
	case []string:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i]) // 字符串转 int64（依赖 Int64 中的 strconv.ParseInt）
		}
	case *[]string:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}

	// --------------- 布尔值切片及指针 ---------------
	case []bool:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i]) // bool 转 1/0（依赖 Int64 中的布尔值处理）
		}
	case *[]bool:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}

	// --------------- 接口切片及指针（元素类型需是 Int64 支持的类型） ---------------
	case []interface{}:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i]) // 每个 interface{} 元素转 int64
		}
	case *[]interface{}:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}

	// --------------- 二维字节切片及指针（每个子切片转 int64） ---------------
	case [][]byte:
		slice = make([]int64, len(v))
		for i := range v {
			slice[i] = Int64(v[i]) // 子切片 []byte 转 int64（依赖 Int64 中的字节切片处理）
		}
	case *[][]byte:
		slice = make([]int64, len(*v))
		for i := range *v {
			slice[i] = Int64((*v)[i])
		}

	// --------------- 兜底：处理数组、未覆盖的切片类型（用反射） ---------------
	default:
		// 1. 初始化反射对象：获取输入值的反射值和类型
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		// 2. 循环解引用指针：处理数组指针、切片指针（如 *[3]int、**[]int）
		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		// 3. 仅处理切片（reflect.Slice）或数组（reflect.Array）类型
		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()            // 获取容器长度（切片/数组的元素个数）
			slice = make([]int64, count) // 初始化结果切片
			for i := 0; i < count; i++ {
				// rv.Index(i)：获取第 i 个元素的反射值
				// .Interface()：将反射值转为 interface{}（还原元素原始类型）
				// Int64(...)：调用 Int64 转换为 int64
				slice[i] = Int64(rv.Index(i).Interface())
			}
			// 非切片/数组类型（如 int、struct），不处理，保持 slice 为 nil
		}
	}

	// 返回转换结果：若输入是支持的容器类型，返回 []int64；否则返回 nil
	return
}

// Int64Pointer 核心功能：调用 Int64() 获取 int64 值，并返回其指针
// 设计意图：满足需要「int64 指针类型」的场景（如结构体字段赋值、函数参数要求指针）
// 参数：
//
//	any - 待转换的任意类型值（同 Int64() 的参数要求）
//
// 返回值：
//
//	*int64 - 转换后的 int64 值的指针；Int64() 返回 0 时，指针指向 0
func Int64Pointer(any interface{}) *int64 {
	// 第一步：调用 Int64() 转换输入值，得到 int64 类型结果
	v := Int64(any)
	// 第二步：返回 int64 值的地址（指针）
	return &v
}

// Int64sPointer 核心功能：调用 Int64s() 获取 []int64 切片，并返回其指针
// 设计意图：满足需要「[]int64 指针类型」的场景（如函数参数要求切片指针，避免切片拷贝）
// 参数：
//
//	any - 待转换的容器类型（同 Int64s() 的参数要求）
//
// 返回值：
//
//	*[]int64 - 转换后的 []int64 切片的指针；Int64s() 返回 nil 时，指针指向 nil 切片
func Int64sPointer(any interface{}) *[]int64 {
	// 第一步：调用 Int64s() 转换输入容器，得到 []int64 切片
	v := Int64s(any)
	// 第二步：返回切片的地址（指针）
	return &v
}

/* int32 */

func Int32(any interface{}) int32 {
	return int32(Int64(any))
}

func Int32s(any interface{}) (slice []int32) {
	if any == nil {
		return
	}

	switch v := any.(type) {
	case []int:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]int:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []int8:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]int8:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []int16:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]int16:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []int32:
		return v
	case *[]int32:
		return *v
	case []int64:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]int64:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []uint:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]uint:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []uint8:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]uint8:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []uint16:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]uint16:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []uint32:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]uint32:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []uint64:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]uint64:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []float32:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]float32:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []float64:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]float64:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []complex64:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]complex64:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []complex128:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]complex128:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []string:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]string:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []bool:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]bool:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case []interface{}:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[]interface{}:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	case [][]byte:
		slice = make([]int32, len(v))
		for i := range v {
			slice[i] = Int32(v[i])
		}
	case *[][]byte:
		slice = make([]int32, len(*v))
		for i := range *v {
			slice[i] = Int32((*v)[i])
		}
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()
			slice = make([]int32, count)
			for i := 0; i < count; i++ {
				slice[i] = Int32(rv.Index(i).Interface())
			}
		}
	}

	return
}

func Int32Pointer(any interface{}) *int32 {
	v := Int32(any)
	return &v
}

func Int32sPointer(any interface{}) *[]int32 {
	v := Int32s(any)
	return &v
}

/* int16 */

func Int16(any interface{}) int16 {
	return int16(Int64(any))
}

func Int16s(any interface{}) (slice []int16) {
	if any == nil {
		return
	}

	switch v := any.(type) {
	case []int:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]int:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []int8:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]int8:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []int16:
		return v
	case *[]int16:
		return *v
	case []int32:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]int32:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []int64:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]int64:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []uint:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]uint:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []uint8:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]uint8:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []uint16:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]uint16:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []uint32:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]uint32:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []uint64:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]uint64:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []float32:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]float32:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []float64:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]float64:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []complex64:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]complex64:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []complex128:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]complex128:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []string:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]string:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []bool:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]bool:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case []interface{}:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[]interface{}:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	case [][]byte:
		slice = make([]int16, len(v))
		for i := range v {
			slice[i] = Int16(v[i])
		}
	case *[][]byte:
		slice = make([]int16, len(*v))
		for i := range *v {
			slice[i] = Int16((*v)[i])
		}
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()
			slice = make([]int16, count)
			for i := 0; i < count; i++ {
				slice[i] = Int16(rv.Index(i).Interface())
			}
		}
	}

	return
}

func Int16Pointer(any interface{}) *int16 {
	v := Int16(any)
	return &v
}

func Int16sPointer(any interface{}) *[]int16 {
	v := Int16s(any)
	return &v
}

/* int8 */

func Int8(any interface{}) int8 {
	return int8(Int64(any))
}

func Int8s(any interface{}) (slice []int8) {
	if any == nil {
		return
	}

	switch v := any.(type) {
	case []int:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]int:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []int8:
		return v
	case *[]int8:
		return *v
	case []int16:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]int16:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []int32:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]int32:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []int64:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]int64:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []uint:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]uint:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []uint8:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]uint8:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []uint16:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]uint16:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []uint32:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]uint32:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []uint64:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]uint64:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []float32:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]float32:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []float64:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]float64:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []complex64:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]complex64:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []complex128:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]complex128:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []string:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]string:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []bool:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]bool:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case []interface{}:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[]interface{}:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	case [][]byte:
		slice = make([]int8, len(v))
		for i := range v {
			slice[i] = Int8(v[i])
		}
	case *[][]byte:
		slice = make([]int8, len(*v))
		for i := range *v {
			slice[i] = Int8((*v)[i])
		}
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()
			slice = make([]int8, count)
			for i := 0; i < count; i++ {
				slice[i] = Int8(rv.Index(i).Interface())
			}
		}
	}

	return
}

func Int8Pointer(any interface{}) *int8 {
	v := Int8(any)
	return &v
}

func Int8sPointer(any interface{}) *[]int8 {
	v := Int8s(any)
	return &v
}

/* int */

func Int(any interface{}) int {
	return int(Int64(any))
}

func Ints(any interface{}) (slice []int) {
	if any == nil {
		return
	}

	switch v := any.(type) {
	case []int:
		return v
	case *[]int:
		return *v
	case []int8:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]int8:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []int16:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]int16:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []int32:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]int32:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []int64:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]int64:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []uint:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]uint:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []uint8:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]uint8:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []uint16:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]uint16:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []uint32:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]uint32:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []uint64:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]uint64:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []float32:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]float32:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []float64:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]float64:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []complex64:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]complex64:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []complex128:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]complex128:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []string:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]string:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []bool:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]bool:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case []interface{}:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[]interface{}:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	case [][]byte:
		slice = make([]int, len(v))
		for i := range v {
			slice[i] = Int(v[i])
		}
	case *[][]byte:
		slice = make([]int, len(*v))
		for i := range *v {
			slice[i] = Int((*v)[i])
		}
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()
			slice = make([]int, count)
			for i := 0; i < count; i++ {
				slice[i] = Int(rv.Index(i).Interface())
			}
		}
	}

	return
}

func IntPointer(any interface{}) *int {
	v := Int(any)
	return &v
}

func IntsPointer(any interface{}) *[]int {
	v := Ints(any)
	return &v
}

/* float64 */

// Float64 核心功能：将任意支持类型的单个值转换为 float64 类型
// 设计意图：提供统一的浮点型转换入口，覆盖基础类型、指针、复数、时间等，解决多类型转浮点的冗余代码问题
// 功能特性：
//  1. 输入为 nil 时返回 0.0，避免空指针 panic
//  2. 支持指针自动解引用（如 *int → int → float64）
//  3. 特殊处理复数：通过字符串中间转换，保留实部+虚部的数值信息（如 1+2i → 12.0，具体取决于字符串格式化结果）
//  4. 时间类型转纳秒级时间戳（float64 存储，适配需要浮点时间戳的场景）
//  5. 不支持类型（如结构体、map）返回 0.0，保证函数安全性
//
// 参数：
//
//	any - 待转换的任意类型值（支持基础类型、指针、complex、time.Time 等）
//
// 返回值：
//
//	float64 - 转换后的浮点值；不支持类型或转换失败时返回 0.0
func Float64(any interface{}) float64 {
	// 第一步：处理输入为 nil 的场景
	// 若输入是 nil（如 var x *float32 = nil），直接返回 0.0，避免后续类型断言/反射报错
	if any == nil {
		return 0
	}

	// 定义内部函数 toFloat64：专门处理复数转 float64（核心逻辑：复数→字符串→浮点）
	// 设计原因：Go 无直接方法将 complex 转 float64，通过字符串中间层可保留复数的数值信息
	toFloat64 := func(v complex128) float64 {
		// 1. 将 complex128 格式化为字符串：'f' 表示小数格式，-1 表示自动决定小数位数，64 表示复数精度
		// 例：complex(3.14, 2.71) → "3.14+2.71i"，complex(-1.5, 0) → "-1.5+0i"
		s := strconv.FormatComplex(v, 'f', -1, 64)
		// 2. 将格式化后的字符串解析为 float64（忽略错误：若解析失败返回 0.0，符合容错设计）
		// 例："3.14+2.71i" 会因字符 '+' 和 'i' 解析失败返回 0.0？实际需注意：此处逻辑需结合业务场景，若仅需实部，建议改为取 real(v) 后转 float64
		f, _ := strconv.ParseFloat(s, 64)
		return f
	}

	// 第二步：优先通过「类型断言」处理常见类型（效率高于反射，减少运行时开销）
	// 类型断言语法：any.(type) 仅能在 switch 中使用，精确匹配变量的具体类型
	switch v := any.(type) {
	// --------------- 处理有符号整数及指针（直接强转，无精度丢失风险） ---------------
	case int:
		// int 转 float64：如 int(5) → float64(5.0)
		return float64(v)
	case *int:
		// 先解引用指针（*v 获取 int 值），再转 float64：如 *int(5) → 5.0
		return float64(*v)
	case int8:
		// int8（-128~127）范围远小于 float64 表示范围，直接转换
		return float64(v)
	case *int8:
		return float64(*v)
	case int16:
		return float64(v)
	case *int16:
		return float64(*v)
	case int32:
		return float64(v)
	case *int32:
		return float64(*v)
	case int64:
		// int64 最大值（9e18）小于 float64 精确表示上限（~2^53），直接转换无精度丢失
		return float64(v)
	case *int64:
		return float64(*v)

	// --------------- 处理无符号整数及指针（直接强转，注意：uint64 超大值可能丢失精度） ---------------
	case uint:
		return float64(v)
	case *uint:
		return float64(*v)
	case uint8: // 即 byte 类型
		return float64(v)
	case *uint8:
		return float64(*v)
	case uint16:
		return float64(v)
	case *uint16:
		return float64(*v)
	case uint32:
		return float64(v)
	case *uint32:
		return float64(*v)
	case uint64:
		// 注意：uint64 最大值（1.8e19）超过 float64 精确表示上限（~9e15），超大值转换会丢失精度
		// 例：uint64(1 << 54) → float64 后可能无法精确还原
		return float64(v)
	case *uint64:
		return float64(*v)

	// --------------- 处理浮点数及指针（float32 转 float64 无精度丢失，直接复用） ---------------
	case float32:
		// float32 精度（23 位小数）低于 float64（52 位），转 float64 可保留全部精度
		return float64(v)
	case *float32:
		return float64(*v)
	case float64:
		// 类型一致，直接返回原值（无需转换，提升效率）
		return v
	case *float64:
		return *v

	// --------------- 处理复数及指针（调用内部 toFloat64 函数，通过字符串中间转换） ---------------
	case complex64:
		// 先将 complex64 转为 complex128（兼容内部函数参数类型），再调用 toFloat64
		return toFloat64(complex128(v))
	case *complex64:
		return toFloat64(complex128(*v))
	case complex128:
		return toFloat64(v)
	case *complex128:
		return toFloat64(*v)

	// --------------- 处理布尔值及指针（约定：true→1.0，false→0.0，符合常见业务逻辑） ---------------
	case bool:
		if v {
			return 1.0
		}
		return 0.0
	case *bool:
		if *v {
			return 1.0
		}
		return 0.0

	// --------------- 处理时间类型及指针（转纳秒级时间戳，用 float64 存储适配浮点时间场景） ---------------
	case time.Time:
		// UnixNano() 返回 int64 类型的纳秒时间戳，转 float64 可适配需要浮点时间的场景（如某些时序数据库）
		return float64(v.UnixNano())
	case *time.Time:
		return float64(v.UnixNano())

	// --------------- 兜底：处理上述未覆盖的类型（用反射进一步转换，保证兼容性） ---------------
	default:
		// 1. 初始化反射对象：获取输入值的反射值（reflect.Value，可操作实际值）和类型（reflect.Kind）
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		// 2. 循环解引用指针：处理多级指针（如 **string、***int），直到获取非指针类型
		// 例：**int → *int → int，确保后续处理的是原始值而非指针
		for kind == reflect.Ptr {
			rv = rv.Elem()   // 解引用：获取指针指向的元素（如 *int → int 的反射值）
			kind = rv.Kind() // 更新类型，继续判断是否为指针
		}

		// 3. 根据解引用后的类型，通过反射方法获取值并转换为 float64
		switch kind {
		case reflect.Bool:
			// 反射值转 bool 后，递归调用 Float64 复用布尔值转 1.0/0.0 的逻辑
			return Float64(rv.Bool())
		case reflect.String:
			// 字符串转 float64：strconv.ParseFloat 第二个参数 64 表示目标类型是 float64
			// 忽略错误：若字符串无法转浮点（如 "abc123"），返回 0.0，符合容错设计
			i, _ := strconv.ParseFloat(rv.String(), 64)
			return i
		case reflect.Uintptr:
			// Uintptr 是指针的整数表示，rv.Uint() 获取其 uint64 值，再转 float64
			return float64(rv.Uint())
		case reflect.UnsafePointer:
			// UnsafePointer 是无类型指针，rv.Pointer() 获取其 uintptr 值，再转 float64
			return float64(rv.Pointer())
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			// 有符号整数类型：rv.Int() 返回 int64 值，直接转 float64
			return float64(rv.Int())
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			// 无符号整数类型：rv.Uint() 返回 uint64 值，直接转 float64
			return float64(rv.Uint())
		case reflect.Float32, reflect.Float64:
			// 浮点数类型：rv.Float() 直接返回 float64 值（反射已处理类型适配）
			return rv.Float()
		case reflect.Complex64, reflect.Complex128:
			// 复数类型：rv.Complex() 返回 complex128 值，调用内部 toFloat64 转换
			return toFloat64(rv.Complex())
		default:
			// 不支持的类型（如结构体、map、channel、函数等），返回 0.0
			return 0.0
		}
	}
}

// Float64s 核心功能：将输入的「切片/数组」（含指针）转换为 []float64 类型
// 设计意图：统一处理各类基础类型切片/数组，自动转换为浮点切片，避免重复的遍历+转换逻辑
// 功能特性：
//  1. 支持直接切片（如 []int）、切片指针（如 *[]float32）、数组（如 [5]bool）
//  2. 每个元素通过 Float64() 转换，保证切片元素类型统一为 float64
//  3. 输入为 nil 或非容器类型时，返回空的 []float64（nil）
//
// 参数：
//
//	any - 待转换的容器类型（支持切片、数组及其指针，元素类型需是 Float64() 支持的类型）
//
// 返回值：
//
//	[]float64 - 转换后的浮点切片；转换失败时返回 nil
func Float64s(any interface{}) (slice []float64) {
	// 第一步：处理输入为 nil 的场景（如 var s []int = nil），直接返回空切片
	if any == nil {
		return
	}

	// 第二步：优先通过「类型断言」处理常见切片/切片指针（效率高于反射，减少运行时开销）
	// 核心逻辑：匹配切片类型 → 初始化同等长度的 []float64 → 遍历元素调用 Float64() 转换
	switch v := any.(type) {
	// --------------- 有符号整数切片及指针 ---------------
	case []int:
		slice = make([]float64, len(v)) // 初始化结果切片，长度与输入切片一致
		for i := range v {
			slice[i] = Float64(v[i]) // 每个元素调用 Float64 转浮点
		}
	case *[]int:
		slice = make([]float64, len(*v)) // 先解引用切片指针，再初始化长度
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}
	case []int8:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i])
		}
	case *[]int8:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}
	case []int16:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i])
		}
	case *[]int16:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}
	case []int32:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i])
		}
	case *[]int32:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}
	case []int64:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i])
		}
	case *[]int64:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}

	// --------------- 无符号整数切片及指针 ---------------
	case []uint:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i])
		}
	case *[]uint:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}
	case []uint8: // 即 []byte
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i])
		}
	case *[]uint8:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}
	case []uint16:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i])
		}
	case *[]uint16:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}
	case []uint32:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i])
		}
	case *[]uint32:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}
	case []uint64:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i])
		}
	case *[]uint64:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}

	// --------------- 浮点数切片及指针 ---------------
	case []float32:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i]) // 复用 float32→float64 的逻辑
		}
	case *[]float32:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}
	case []float64:
		// 类型一致，直接返回原切片（无需拷贝，提升效率）
		return v
	case *[]float64:
		// 解引用后直接返回，避免切片拷贝
		return *v

	// --------------- 复数切片及指针 ---------------
	case []complex64:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i]) // 复用复数转浮点的逻辑
		}
	case *[]complex64:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}
	case []complex128:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i])
		}
	case *[]complex128:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}

	// --------------- 字符串切片及指针 ---------------
	case []string:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i]) // 复用字符串转浮点的逻辑
		}
	case *[]string:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}

	// --------------- 布尔值切片及指针 ---------------
	case []bool:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i]) // 复用 bool→1.0/0.0 的逻辑
		}
	case *[]bool:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}

	// --------------- 接口切片及指针（元素类型需是 Float64 支持的类型） ---------------
	case []interface{}:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i]) // 每个 interface{} 元素转浮点
		}
	case *[]interface{}:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}

	// --------------- 二维字节切片及指针（每个子切片元素转浮点） ---------------
	case [][]byte:
		slice = make([]float64, len(v))
		for i := range v {
			slice[i] = Float64(v[i]) // 子切片 []byte 转浮点（依赖 Float64 反射处理）
		}
	case *[][]byte:
		slice = make([]float64, len(*v))
		for i := range *v {
			slice[i] = Float64((*v)[i])
		}

	// --------------- 兜底：处理数组、未覆盖的切片类型（用反射保证兼容性） ---------------
	default:
		// 1. 初始化反射对象：获取输入值的反射值和类型
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		// 2. 循环解引用指针：处理数组指针、多级切片指针（如 *[3]int、**[]bool）
		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		// 3. 仅处理切片（reflect.Slice）或数组（reflect.Array）类型
		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()              // 获取容器长度（切片/数组的元素个数）
			slice = make([]float64, count) // 初始化结果切片，长度与容器一致
			for i := 0; i < count; i++ {
				// 步骤分解：
				// 1. rv.Index(i)：通过反射获取容器第 i 个元素的反射值
				// 2. .Interface()：将反射值转为 interface{}，还原元素原始类型
				// 3. Float64(...)：调用 Float64 转换为 float64
				slice[i] = Float64(rv.Index(i).Interface())
			}
			// 非切片/数组类型（如 int、struct、map），不处理，保持 slice 为 nil
		}
	}

	// 返回转换结果：若输入是支持的容器类型，返回 []float64；否则返回 nil
	return
}

// Float64Pointer 核心功能：调用 Float64() 获取 float64 值，并返回其指针
// 设计意图：满足需要「float64 指针类型」的场景（如结构体浮点字段赋值、函数参数要求指针传入）
// 参数：
//
//	any - 待转换的任意类型值（同 Float64() 的参数要求）
//
// 返回值：
//
//	*float64 - 转换后的 float64 值的指针；Float64() 返回 0.0 时，指针指向 0.0
func Float64Pointer(any interface{}) *float64 {
	// 第一步：调用 Float64() 转换输入值，得到 float64 类型结果
	v := Float64(any)
	// 第二步：返回 float64 值的内存地址（即指针）
	return &v
}

// Float64sPointer 核心功能：调用 Float64s() 获取 []float64 切片，并返回其指针
// 设计意图：满足需要「[]float64 指针类型」的场景（如函数参数要求切片指针，避免大切片拷贝开销）
// 参数：
//
//	any - 待转换的容器类型（同 Float64s() 的参数要求）
//
// 返回值：
//
//	*[]float64 - 转换后的 []float64 切片的指针；Float64s() 返回 nil 时，指针指向 nil 切片
func Float64sPointer(any interface{}) *[]float64 {
	// 第一步：调用 Float64s() 转换输入容器，得到 []float64 切片
	v := Float64s(any)
	// 第二步：返回切片的内存地址（即指针）
	return &v
}

/* float32 */

func Float32(any interface{}) float32 {
	return float32(Float64(any))
}

func Float32s(any interface{}) (slice []float32) {
	if any == nil {
		return
	}

	switch v := any.(type) {
	case []int:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]int:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []int8:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]int8:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []int16:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]int16:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []int32:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]int32:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []int64:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]int64:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []uint:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]uint:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []uint8:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]uint8:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []uint16:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]uint16:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []uint32:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]uint32:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []uint64:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]uint64:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []float32:
		return v
	case *[]float32:
		return *v
	case []float64:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]float64:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []complex64:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]complex64:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []complex128:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]complex128:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []string:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]string:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []bool:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]bool:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case []interface{}:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[]interface{}:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	case [][]byte:
		slice = make([]float32, len(v))
		for i := range v {
			slice[i] = Float32(v[i])
		}
	case *[][]byte:
		slice = make([]float32, len(*v))
		for i := range *v {
			slice[i] = Float32((*v)[i])
		}
	default:
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()
			slice = make([]float32, count)
			for i := 0; i < count; i++ {
				slice[i] = Float32(rv.Index(i).Interface())
			}
		}
	}

	return
}

func Float32Pointer(any interface{}) *float32 {
	v := Float32(any)
	return &v
}

func Float32sPointer(any interface{}) *[]float32 {
	v := Float32s(any)
	return &v
}

/* duration */

// Duration 核心功能：将任意支持类型的单个值转换为 time.Duration 类型
// 设计意图：解决多类型转时间间隔的通用需求，尤其补充 Go 标准库不支持的「天（d）单位解析」
// 功能特性：
//  1. 输入为 nil 时返回 0（表示无时间间隔），避免空指针 panic
//  2. 支持基础类型（整数/浮点数/复数）、指针、字符串、字节切片、时间类型自动转换
//  3. 扩展标准库能力：通过自定义逻辑解析「天（d）单位」（标准库 time.ParseDuration 不支持 d）
//  4. bool 类型无明确时间语义，统一返回 0；复数仅取实部转换
//  5. 不支持类型（如结构体、map）返回 0，保证函数安全性
//
// 参数：
//
//	any - 待转换的任意类型值（支持基础类型、指针、string、[]byte、time.Time 等）
//
// 返回值：
//
//	time.Duration - 转换后的时间间隔（本质是 int64 纳秒数）；不支持类型返回 0
func Duration(any interface{}) time.Duration {
	// 第一步：处理输入为 nil 的场景
	// 若输入是 nil（如 var t *int = nil），直接返回 0（无时间间隔），避免后续逻辑报错
	if any == nil {
		return 0
	}

	// 定义内部闭包 toDuration：专门处理「字符串转 time.Duration」，核心是支持「d（天）单位」
	// 设计背景：Go 标准库 time.ParseDuration 仅支持 ns/us/ms/s/m/h，不支持 d，此处补充该能力
	// 逻辑核心：将字符串中的「d 单位」转成标准库支持的「ns 单位」，再调用标准库解析
	toDuration := func(s string) time.Duration {
		// 1. 编译正则表达式：匹配字符串中的「天单位表达式」（如 1d、2.5d、-3d）
		// 正则拆解：
		// ((-?\d+)(\.\d+)?)(d) → 分组匹配带符号的数字（整数/小数）+ d 单位
		// 例："2.5d" 匹配结果为 ["2.5d", "2.5", "2", ".5", "d"]
		reg := regexp.MustCompile(`(((-?\d+)(\.\d+)?)(d))`)

		// 2. 替换字符串中的「d 单位」为「ns 单位」：
		// - strings.ToLower(s)：统一小写（避免 D/Dd 等大小写问题，如 "1D" → "1d"）
		// - reg.ReplaceAllStringFunc：对每个匹配到的「d 表达式」执行替换逻辑
		processedStr := reg.ReplaceAllStringFunc(strings.ToLower(s), func(ss string) string {
			// 2.1 去除 ss 末尾的 "d"，提取纯数字字符串（如 "2.5d" → "2.5"）
			numStr := strings.TrimSuffix(ss, "d")
			// 2.2 将数字字符串解析为 float64（支持小数天，如 1.5d = 1 天 12 小时）
			v, err := strconv.ParseFloat(numStr, 64)
			if err != nil { // 解析失败（如 "abc d"），返回空字符串，后续标准库解析会返回 0
				return ""
			}
			// 2.3 将「天」转成「纳秒」：1天 = 24小时 × 3600秒 × 1e9纳秒/秒
			ns := int64(v * 24 * 3600 * 1000 * 1000 * 1000)
			// 2.4 拼接成标准库支持的「ns 单位字符串」（如 2d → "172800000000000ns"）
			return fmt.Sprintf("%dns", ns)
		})

		// 3. 调用标准库解析处理后的字符串（仅含 ns/us/ms/s/m/h 单位）
		// 忽略错误：若字符串仍无效（如 "abc"），ParseDuration 返回 0，符合函数容错设计
		d, _ := time.ParseDuration(processedStr)
		return d
	}

	// 第二步：优先通过「类型断言」处理常见类型（效率高于反射，减少运行时开销）
	// 核心逻辑：按类型特性适配转换，优先复用标准库或简单强转，复杂场景调用 toDuration
	switch v := any.(type) {
	// --------------- 处理有符号整数及指针（直接强转，因 time.Duration 本质是 int64 纳秒） ---------------
	case int:
		// int 转 Duration：如 int(100) → 100ns（Duration 默认单位是纳秒）
		return time.Duration(v)
	case *int:
		// 解引用指针后强转：如 *int(500) → 500ns
		return time.Duration(*v)
	case int8:
		return time.Duration(v)
	case *int8:
		return time.Duration(*v)
	case int16:
		return time.Duration(v)
	case *int16:
		return time.Duration(*v)
	case int32:
		return time.Duration(v)
	case *int32:
		return time.Duration(*v)
	case int64:
		// int64 与 Duration 底层类型一致，直接转换无风险（如 int64(1e9) → 1s）
		return time.Duration(v)
	case *int64:
		return time.Duration(*v)

	// --------------- 处理无符号整数及指针（强转，注意：uint64 超大值可能超出 Duration 范围） ---------------
	case uint:
		return time.Duration(v)
	case *uint:
		return time.Duration(*v)
	case uint8: // 即 byte 类型
		return time.Duration(v)
	case *uint8:
		return time.Duration(*v)
	case uint16:
		return time.Duration(v)
	case *uint16:
		return time.Duration(*v)
	case uint32:
		return time.Duration(v)
	case *uint32:
		return time.Duration(*v)
	case uint64:
		// 注意：Duration 最大值约为 290 年（int64 最大纳秒数），uint64 超大值可能溢出为负
		return time.Duration(v)
	case *uint64:
		return time.Duration(*v)

	// --------------- 处理浮点数及指针（强转，小数部分会截断，如 3.9 → 3ns） ---------------
	case float32:
		return time.Duration(v)
	case *float32:
		return time.Duration(*v)
	case float64:
		return time.Duration(v)
	case *float64:
		return time.Duration(*v)

	// --------------- 处理复数及指针（无时间语义，仅取实部转换，虚部忽略） ---------------
	case complex64:
		// real(v) 取复数实部（如 complex(5, 3) → 5），再转 Duration
		return time.Duration(real(v))
	case *complex64:
		return time.Duration(real(*v))
	case complex128:
		return time.Duration(real(v))
	case *complex128:
		return time.Duration(real(*v))

	// --------------- 处理 bool 及指针（无明确时间语义，统一返回 0） ---------------
	case bool:
		return 0
	case *bool:
		return 0

	// --------------- 处理字符串及指针（调用 toDuration，支持 d 单位解析） ---------------
	case string:
		// 如 "2d" → 2天（转成纳秒）、"1h30m" → 1小时30分钟（标准库原生支持）
		return toDuration(v)
	case *string:
		return toDuration(*v)

	// --------------- 处理字节切片及指针（先转字符串，再调用 toDuration） ---------------
	case []byte:
		// 用 unsafe.Pointer 实现 []byte 到 string 的「零拷贝转换」（高效，避免内存拷贝）
		// 原理：string 和 []byte 在 Go 底层结构相近，直接通过指针转换，不复制数据
		// 注意：unsafe 包会绕过 Go 类型安全检查，若后续修改 []byte，string 也会受影响（此处无修改，风险低）
		str := *(*string)(unsafe.Pointer(&v))
		return toDuration(str)
	case *[]byte:
		// 解引用指针后，同样通过 unsafe 转 string
		str := *(*string)(unsafe.Pointer(v))
		return toDuration(str)

	// --------------- 处理时间类型及指针（转纳秒级时间戳，作为 Duration） ---------------
	case time.Time:
		// UnixNano() 返回从 1970-01-01 UTC 到该时间的纳秒数（int64），直接转 Duration
		// 场景：常用于计算「时间戳对应的时间间隔」（如把某个时间点当作相对于 epoch 的间隔）
		return time.Duration(v.UnixNano())
	case *time.Time:
		return time.Duration(v.UnixNano())

	// --------------- 处理 time.Duration 及指针（类型一致，直接返回，避免冗余转换） ---------------
	case time.Duration:
		return v
	case *time.Duration:
		return *v

	// --------------- 兜底：处理上述未覆盖的类型（用反射进一步转换，保证兼容性） ---------------
	default:
		// 1. 初始化反射对象：获取输入值的反射值（reflect.Value，可操作实际值）和类型（reflect.Kind）
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		// 2. 循环解引用指针：处理多级指针（如 **int、***string），直到获取非指针类型
		// 例：**string → *string → string，确保后续处理的是原始值而非指针
		for kind == reflect.Ptr {
			rv = rv.Elem()   // 解引用：获取指针指向的元素（如 *int → int 的反射值）
			kind = rv.Kind() // 更新类型，继续判断是否为指针
		}

		// 3. 根据解引用后的类型，通过反射方法获取值并转换为 time.Duration
		switch kind {
		case reflect.Bool:
			// 反射值转 bool 后，递归调用 Duration（复用 bool 返回 0 的逻辑）
			return Duration(rv.Bool())
		case reflect.String:
			// 反射值转 string 后，递归调用 Duration（复用 toDuration 逻辑）
			return Duration(rv.String())
		case reflect.Uintptr:
			// Uintptr 是指针的整数表示，rv.Uint() 获取其 uint64 值，转 Duration（作为纳秒）
			return time.Duration(rv.Uint())
		case reflect.UnsafePointer:
			// UnsafePointer 是无类型指针，rv.Pointer() 获取其 uintptr 值，转 Duration
			return time.Duration(rv.Pointer())
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			// 有符号整数类型：rv.Int() 返回 int64 值，直接转 Duration（纳秒）
			return time.Duration(rv.Int())
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			// 无符号整数类型：rv.Uint() 返回 uint64 值，转 Duration
			return time.Duration(rv.Uint())
		case reflect.Float32, reflect.Float64:
			// 浮点数类型：rv.Float() 返回 float64 值，转 Duration（截断小数）
			return time.Duration(rv.Float())
		case reflect.Complex64, reflect.Complex128:
			// 复数类型：rv.Complex() 返回 complex128 值，取实部转 Duration
			return time.Duration(real(rv.Complex()))
		default:
			// 不支持的类型（如结构体、map、channel、函数等），返回 0
			return 0
		}
	}
}

// Durations 核心功能：将输入的「切片/数组」（含指针）转换为 []time.Duration 类型
// 设计意图：统一处理各类基础类型切片/数组的时间间隔转换，避免重复的「遍历+单值转换」逻辑
// 功能特性：
//  1. 支持直接切片（如 []int、[]string）、切片指针（如 *[]byte）、数组（如 [5]time.Time）
//  2. 每个元素通过 Duration() 转换，保证切片元素类型统一为 time.Duration
//  3. 输入为 nil 或非容器类型时，返回空的 []time.Duration（nil）
//
// 参数：
//
//	any - 待转换的容器类型（支持切片、数组及其指针，元素类型需是 Duration() 支持的类型）
//
// 返回值：
//
//	[]time.Duration - 转换后的时间间隔切片；转换失败时返回 nil
func Durations(any interface{}) (slice []time.Duration) {
	// 第一步：处理输入为 nil 的场景（如 var s []string = nil），直接返回空切片
	if any == nil {
		return
	}

	// 第二步：优先通过「类型断言」处理常见切片/切片指针（效率高于反射，减少运行时开销）
	// 核心逻辑：匹配切片类型 → 初始化同等长度的 []time.Duration → 遍历元素调用 Duration() 转换
	switch v := any.(type) {
	// --------------- 有符号整数切片及指针 ---------------
	case []int:
		slice = make([]time.Duration, len(v)) // 初始化结果切片，长度与输入一致
		for i := range v {
			slice[i] = Duration(v[i]) // 每个元素调用 Duration 转时间间隔
		}
	case *[]int:
		slice = make([]time.Duration, len(*v)) // 先解引用切片指针，再初始化长度
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}
	case []int8:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i])
		}
	case *[]int8:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}
	case []int16:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i])
		}
	case *[]int16:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}
	case []int32:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i])
		}
	case *[]int32:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}
	case []int64:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i])
		}
	case *[]int64:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}

	// --------------- 无符号整数切片及指针 ---------------
	case []uint:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i])
		}
	case *[]uint:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}
	case []uint8: // 即 []byte
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i]) // 复用 []byte 转 Duration 的逻辑（unsafe 转 string）
		}
	case *[]uint8:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}
	case []uint16:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i])
		}
	case *[]uint16:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}
	case []uint32:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i])
		}
	case *[]uint32:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}
	case []uint64:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i])
		}
	case *[]uint64:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}

	// --------------- 浮点数切片及指针 ---------------
	case []float32:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i]) // 复用浮点数转 Duration 的逻辑（截断小数）
		}
	case *[]float32:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}
	case []float64:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i])
		}
	case *[]float64:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}

	// --------------- 复数切片及指针 ---------------
	case []complex64:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i]) // 复用复数转 Duration 的逻辑（取实部）
		}
	case *[]complex64:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}
	case []complex128:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i])
		}
	case *[]complex128:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}

	// --------------- 字符串切片及指针 ---------------
	case []string:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i]) // 复用字符串转 Duration 的逻辑（支持 d 单位）
		}
	case *[]string:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}

	// --------------- 布尔值切片及指针 ---------------
	case []bool:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i]) // 复用 bool 转 Duration 的逻辑（返回 0）
		}
	case *[]bool:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}

	// --------------- 接口切片及指针（元素类型需是 Duration 支持的类型） ---------------
	case []interface{}:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i]) // 每个 interface{} 元素转时间间隔
		}
	case *[]interface{}:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}

	// --------------- 二维字节切片及指针（每个子切片转时间间隔） ---------------
	case [][]byte:
		slice = make([]time.Duration, len(v))
		for i := range v {
			slice[i] = Duration(v[i]) // 子切片 []byte 转 Duration（unsafe 转 string）
		}
	case *[][]byte:
		slice = make([]time.Duration, len(*v))
		for i := range *v {
			slice[i] = Duration((*v)[i])
		}

	// --------------- 兜底：处理数组、未覆盖的切片类型（用反射保证兼容性） ---------------
	default:
		// 1. 初始化反射对象：获取输入值的反射值和类型
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		// 2. 循环解引用指针：处理数组指针、多级切片指针（如 *[3]string、**[]int）
		for kind == reflect.Ptr {
			rv = rv.Elem()
			kind = rv.Kind()
		}

		// 3. 仅处理切片（reflect.Slice）或数组（reflect.Array）类型
		switch kind {
		case reflect.Slice, reflect.Array:
			count := rv.Len()                    // 获取容器长度（切片/数组的元素个数）
			slice = make([]time.Duration, count) // 初始化结果切片
			for i := 0; i < count; i++ {
				// 步骤分解：
				// 1. rv.Index(i)：通过反射获取容器第 i 个元素的反射值
				// 2. .Interface()：将反射值转为 interface{}，还原元素原始类型
				// 3. Duration(...)：调用 Duration 转换为 time.Duration
				slice[i] = Duration(rv.Index(i).Interface())
			}
			// 非切片/数组类型（如 int、struct、map），不处理，保持 slice 为 nil
		}
	}

	// 返回转换结果：若输入是支持的容器类型，返回 []time.Duration；否则返回 nil
	return
}

// DurationPointer 核心功能：调用 Duration() 获取 time.Duration 值，并返回其指针
// 设计意图：满足需要「time.Duration 指针类型」的场景（如结构体时间间隔字段赋值、函数参数要求指针传入）
// 参数：
//
//	any - 待转换的任意类型值（同 Duration() 的参数要求）
//
// 返回值：
//
//	*time.Duration - 转换后的时间间隔的指针；Duration() 返回 0 时，指针指向 0
func DurationPointer(any interface{}) *time.Duration {
	// 第一步：调用 Duration() 转换输入值，得到 time.Duration 类型结果
	v := Duration(any)
	// 第二步：返回 time.Duration 值的内存地址（即指针）
	return &v
}

// DurationsPointer 核心功能：调用 Durations() 获取 []time.Duration 切片，并返回其指针
// 设计意图：满足需要「[]time.Duration 指针类型」的场景（如函数参数要求切片指针，避免大切片拷贝开销）
// 参数：
//
//	any - 待转换的容器类型（同 Durations() 的参数要求）
//
// 返回值：
//
//	*[]time.Duration - 转换后的时间间隔切片的指针；Durations() 返回 nil 时，指针指向 nil 切片
func DurationsPointer(any interface{}) *[]time.Duration {
	// 第一步：调用 Durations() 转换输入容器，得到 []time.Duration 切片
	v := Durations(any)
	// 第二步：返回切片的内存地址（即指针）
	return &v
}

/* byte */

// 看来这块内容都是希望以大端为主了

// StringToBytes （注：该函数未在当前代码块中定义，推测为项目内通用工具函数）
// 核心功能：将字符串转换为 []byte 类型（通常为直接强转，如 []byte(s)，或零拷贝转换）
// 参数：s - 待转换的字符串；返回值：对应的 []byte

// Byte 核心功能：将任意支持类型的值转换为 byte 类型（即 uint8）
// 设计意图：作为 Uint8() 函数的「语法糖」，因 Go 中 byte 本质是 uint8 的别名，直接复用 Uint8 的转换逻辑
// 功能特性：
//  1. 完全依赖 Uint8() 实现，转换规则与 Uint8() 完全一致（如 int→uint8、string→uint8 等）
//  2. 输入为 nil 或不支持类型时，返回值与 Uint8() 保持一致（通常为 0）
//
// 参数：
//
//	any - 待转换的任意类型值（同 Uint8() 的参数要求）
//
// 返回值：
//
//	byte - 转换后的字节值；不支持类型返回值由 Uint8() 决定
func Byte(any interface{}) byte {
	// 直接调用 Uint8() 函数获取结果，因 byte ≡ uint8，无需额外转换
	return Uint8(any)
}

// Bytes 核心功能：将任意支持类型的值转换为 []byte 类型（字节切片）
// 设计意图：提供「全类型转字节」的通用入口，覆盖基础类型、复杂类型，适配二进制传输/存储场景
// 功能特性：
//  1. 基础数值类型（整数/浮点数等）：按大端序（网络字节序）转为二进制字节流
//  2. 字符串/字节切片：直接转换或返回原值，避免冗余操作
//  3. 复数类型：无通用二进制转换场景，直接返回 nil
//  4. 复杂类型（结构体、map 等）：通过 JSON 序列化转为 []byte（兜底逻辑）
//  5. 输入为 nil 或转换失败时，返回 nil
//
// 参数：
//
//	any - 待转换的任意类型值（支持基础类型、字符串、字节切片、复杂结构体等）
//
// 返回值：
//
//	[]byte - 转换后的字节切片；不支持类型或转换失败时返回 nil
func Bytes(any interface{}) []byte {
	// 第一步：处理输入为 nil 的场景
	// 若输入是 nil（如 var x *int = nil），直接返回 nil，避免后续逻辑报错
	if any == nil {
		return nil
	}

	// 初始化二进制写入缓冲区：bytes.NewBuffer(nil) 创建空缓冲区，用于存储基础类型的二进制字节
	var (
		err error                  // 存储 binary.Write/JSON 序列化的错误信息
		buf = bytes.NewBuffer(nil) // 二进制缓冲区，承接基础类型的二进制数据
	)

	// 第二步：优先通过「类型断言」处理常见类型（效率高于反射，减少运行时开销）
	// 核心逻辑：按类型特性适配转换方式——基础数值用 binary.Write（大端序），字符串/字节切片直接处理
	switch v := any.(type) {
	// --------------- 处理 int/uint 类型（转成 64 位避免平台位数差异） ---------------
	case int:
		// int 转 int64 后，按大端序写入缓冲区：适配 32/64 位系统 int 位数差异（统一为 8 字节）
		err = binary.Write(buf, binary.BigEndian, int64(v))
	case *int:
		// 解引用指针后转 int64，按大端序写入
		err = binary.Write(buf, binary.BigEndian, int64(*v))
	case uint:
		// uint 转 uint64 后，按大端序写入：适配不同平台 uint 位数差异（统一为 8 字节）
		err = binary.Write(buf, binary.BigEndian, uint64(v))
	case *uint:
		// 解引用指针后转 uint64，按大端序写入
		err = binary.Write(buf, binary.BigEndian, uint64(*v))

	// --------------- 处理常见基础类型（直接按大端序写入，binary.Write 自动适配类型） ---------------
	// 覆盖 bool、有符号/无符号整数（8-64位）、浮点数（32/64位）及其指针
	case bool, *bool, int8, *int8, int16, *int16, int32, *int32, int64, *int64,
		uint8, *uint8, uint16, *uint16, uint32, *uint32, uint64, *uint64,
		float32, *float32, float64, *float64:
		// binary.Write 会自动识别类型并按大端序写入对应长度的二进制（如 int8 写 1 字节，float64 写 8 字节）
		err = binary.Write(buf, binary.BigEndian, v)

	// --------------- 处理 uintptr 类型（转 uint64 后写入，避免指针位数差异） ---------------
	case uintptr:
		// uintptr 是指针的整数表示，转 uint64 后按大端序写入（适配 32/64 位系统指针位数）
		err = binary.Write(buf, binary.BigEndian, uint64(v))
	case *uintptr:
		// 解引用指针后转 uint64，按大端序写入
		err = binary.Write(buf, binary.BigEndian, uint64(*v))

	// --------------- 处理复数类型（无通用二进制场景，直接返回 nil） ---------------
	case complex64, *complex64, complex128, *complex128:
		// 复数由「实部+虚部」组成，无统一的二进制转换标准（如网络传输、存储极少用复数二进制），故不支持
		return nil

	// --------------- 处理字符串类型（调用 StringToBytes 转字节切片，复用项目工具函数） ---------------
	case string:
		// 字符串转 []byte，依赖项目内通用工具函数 StringToBytes（通常为 []byte(v) 或零拷贝实现）
		return StringToBytes(v)
	case *string:
		// 解引用指针后转 []byte
		return StringToBytes(*v)

	// --------------- 处理字节切片类型（直接返回原值/解引用值，避免拷贝） ---------------
	case []byte:
		// 类型一致，直接返回原切片（无需拷贝，提升效率）
		return v
	case *[]byte:
		// 解引用指针后返回切片（避免返回指针，符合「返回值为切片」的设计）
		return *v

	// --------------- 兜底：处理上述未覆盖的类型（用反射进一步转换，兼容复杂类型） ---------------
	default:
		// 1. 初始化反射对象：获取输入值的反射值（reflect.Value，可操作实际值）和类型（reflect.Kind）
		var (
			rv   = reflect.ValueOf(any)
			kind = rv.Kind()
		)

		// 2. 循环解引用指针：处理多级指针（如 **struct、***int），直到获取非指针类型
		// 例：**struct → *struct → struct，确保后续处理的是原始值而非指针
		for kind == reflect.Ptr {
			rv = rv.Elem()   // 解引用：获取指针指向的元素（如 *struct → struct 的反射值）
			kind = rv.Kind() // 更新类型，继续判断是否为指针
		}

		// 3. 根据解引用后的反射类型，适配转换方式
		switch kind {
		case reflect.Invalid:
			// 无效类型（如 nil 已在开头处理，此处理论不触发），返回 nil
			return nil
		case reflect.Bool:
			// 反射值转 bool，按大端序写入缓冲区
			err = binary.Write(buf, binary.BigEndian, rv.Bool())
		case reflect.String:
			// 反射值转 string，调用 StringToBytes 转 []byte
			return StringToBytes(rv.String())
		// 有符号整数类型：按对应位数转后写入（如 int8 转 int8，避免溢出）
		case reflect.Int, reflect.Int64:
			err = binary.Write(buf, binary.BigEndian, rv.Int())
		case reflect.Int8:
			err = binary.Write(buf, binary.BigEndian, int8(rv.Int()))
		case reflect.Int16:
			err = binary.Write(buf, binary.BigEndian, int16(rv.Int()))
		case reflect.Int32:
			err = binary.Write(buf, binary.BigEndian, int32(rv.Int()))
		// 无符号整数类型：按对应位数转后写入（如 uint8 转 uint8）
		case reflect.Uint, reflect.Uint64, reflect.Uintptr:
			err = binary.Write(buf, binary.BigEndian, rv.Uint())
		case reflect.Uint8:
			err = binary.Write(buf, binary.BigEndian, uint8(rv.Uint()))
		case reflect.Uint16:
			err = binary.Write(buf, binary.BigEndian, uint16(rv.Uint()))
		case reflect.Uint32:
			err = binary.Write(buf, binary.BigEndian, uint32(rv.Uint()))
		// 浮点数类型：直接写入反射值（rv.Float() 返回 float64，binary.Write 自动适配）
		case reflect.Float32, reflect.Float64:
			err = binary.Write(buf, binary.BigEndian, rv.Float())
		// 复数类型：反射场景同样不支持，返回 nil
		case reflect.Complex64, reflect.Complex128:
			return nil
		// 复杂类型（如 struct、map、slice 等）：用 JSON 序列化兜底
		default:
			// 对结构体、map 等无二进制标准的类型，序列化为 JSON 字节流（通用兼容方案）
			// 例：struct{ Name string; Age int } → {"Name":"xxx","Age":xx} 的 []byte
			b, err := json.Marshal(v)
			if err != nil { // JSON 序列化失败（如循环引用），返回 nil
				return nil
			}
			return b
		}
	}

	// 第三步：处理 binary.Write 的错误
	// 若写入缓冲区失败（如类型不支持，理论极少触发），返回 nil
	if err != nil {
		return nil
	}

	// 第四步：返回缓冲区中的字节切片
	// buf.Bytes() 返回缓冲区存储的二进制字节（如 int64(1) 按大端序 → []byte{0,0,0,0,0,0,0,1}）
	return buf.Bytes()
}

// BytePointer 核心功能：调用 Byte() 获取 byte 值，并返回其指针
// 设计意图：满足需要「byte 指针类型」的场景（如结构体字节字段赋值、函数参数要求指针传入）
// 参数：
//
//	any - 待转换的任意类型值（同 Byte() 的参数要求）
//
// 返回值：
//
//	*byte - 转换后的字节值的指针；Byte() 返回 0 时，指针指向 0
func BytePointer(any interface{}) *byte {
	// 第一步：调用 Byte() 转换输入值，得到 byte 类型结果
	v := Byte(any)
	// 第二步：返回 byte 值的内存地址（即指针）
	return &v
}

// BytesPointer 核心功能：调用 Bytes() 获取 []byte 切片，并返回其指针
// 设计意图：满足需要「[]byte 指针类型」的场景（如函数参数要求切片指针，避免大切片拷贝开销）
// 参数：
//
//	any - 待转换的任意类型值（同 Bytes() 的参数要求）
//
// 返回值：
//
//	*[]byte - 转换后的字节切片的指针；Bytes() 返回 nil 时，指针指向 nil 切片
func BytesPointer(any interface{}) *[]byte {
	// 第一步：调用 Bytes() 转换输入值，得到 []byte 类型结果
	v := Bytes(any)
	// 第二步：返回 []byte 切片的内存地址（即指针）
	return &v
}

/* any */

func Anys(any interface{}) []interface{} {
	if any == nil {
		return nil
	}

	switch rk, rv := rreflect.Value(any); rk {
	case reflect.Slice, reflect.Array:
		count := rv.Len()
		slice := make([]interface{}, count)
		for i := 0; i < count; i++ {
			slice[i] = rv.Index(i).Interface()
		}
		return slice
	default:
		return nil
	}
}
